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

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

void SystemSettings::save(const K::File& file) {

	XMLDocument doc;
	XMLElement* nRoot = doc.NewElement("KSynth");
	XMLElement* nSettings = doc.NewElement("Settings");

	doc.InsertFirstChild(nRoot);
	nRoot->InsertEndChild(nSettings);

	// the sound-sink
	XMLElement* nSink = doc.NewElement("SoundSink");
	nSink->SetAttribute("name", getSoundSink()->getName().c_str());
	nSettings->InsertEndChild(nSink);

	// refresh
	XMLElement* nGui = doc.NewElement("GUI");
	nSettings->InsertEndChild(nGui);
	XMLElement* nGuiRefresh = doc.NewElement("Refresh");
	nGuiRefresh->SetAttribute("ms", getGuiRefreshInterval());
	nGui->InsertEndChild(nGuiRefresh);



	doc.SaveFile( file.getAbsolutePath().c_str() );

}

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

//.........这里部分代码省略.........
	{
		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() );
		XMLTest( "Programmatic DOM", "0", doc->FirstChildElement( "element" )->FirstChildElement()->Attribute( "attrib" ) );
		XMLTest( "Programmatic DOM", 2, doc->FirstChildElement()->LastChildElement( "sub" )->IntAttribute( "attrib" ) );
		XMLTest( "Programmatic DOM", "& Text!",
				 doc->FirstChildElement()->LastChildElement( "sub" )->FirstChild()->ToText()->Value() );

		// And now deletion:
		element->DeleteChild( sub[2] );
		doc->DeleteNode( comment );

		element->FirstChildElement()->SetAttribute( "attrib", true );
		element->LastChildElement()->DeleteAttribute( "attrib" );

		XMLTest( "Programmatic DOM", true, doc->FirstChildElement()->FirstChildElement()->BoolAttribute( "attrib" ) );
		int value = 10;
		int result = doc->FirstChildElement()->LastChildElement()->QueryIntAttribute( "attrib", &value );
		XMLTest( "Programmatic DOM", result, (int)XML_NO_ATTRIBUTE );
		XMLTest( "Programmatic DOM", value, 10 );

		doc->Print();

		{
			XMLPrinter streamer;
			doc->Print( &streamer );
			printf( "%s", streamer.CStr() );
		}
		{
			XMLPrinter streamer( 0, true );

//.........这里部分代码省略.........
	{
		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() );
		XMLTest( "Programmatic DOM", "0", doc->FirstChildElement( "element" )->FirstChildElement()->Attribute( "attrib" ) );
		XMLTest( "Programmatic DOM", 2, doc->FirstChildElement()->LastChildElement( "sub" )->IntAttribute( "attrib" ) );
		XMLTest( "Programmatic DOM", "& Text!", 
				 doc->FirstChildElement()->LastChildElement( "sub" )->FirstChild()->ToText()->Value() );

		// And now deletion:
		element->DeleteChild( sub[2] );
		doc->DeleteNode( comment );

		element->FirstChildElement()->SetAttribute( "attrib", true );
		element->LastChildElement()->DeleteAttribute( "attrib" );

		XMLTest( "Programmatic DOM", true, doc->FirstChildElement()->FirstChildElement()->BoolAttribute( "attrib" ) );
		int value = 10;
		int result = doc->FirstChildElement()->LastChildElement()->QueryIntAttribute( "attrib", &value );
		XMLTest( "Programmatic DOM", result, XML_NO_ATTRIBUTE );
		XMLTest( "Programmatic DOM", value, 10 );

		doc->Print();

		XMLPrinter streamer;
		doc->Print( &streamer );
		printf( "%s", streamer.CStr() );

		delete doc;
	}
	{

//TODO: Severe problem if unknown ID and this isn't read first!!!
bool sndManifestToXML(const wchar_t* cFilename)
{
	FILE* f = _wfopen(cFilename, TEXT("rb"));
	if(f == NULL)
	{
		cout << "Unable to open " << cFilename << endl;
		return false;
	}
	
	//Read in the soundManifestHeader
	soundManifestHeader smh;
	if(fread(&smh, 1, sizeof(soundManifestHeader), f) != sizeof(soundManifestHeader))
	{
		cout << "Unable to read soundManifestHeader in file " << cFilename << endl;
		fclose(f);
		return false;
	}
	
	//Read in the take groups
	fseek(f, smh.sounds.offset, SEEK_SET);
	list<soundTakeGroup> lSoundTakeGroups;
	for(i32 i = 0; i < smh.sounds.count; i++)
	{
		soundTakeGroup stg;
		if(fread(&stg, 1, sizeof(soundTakeGroup), f) != sizeof(soundTakeGroup))
		{
			cout << "Error reading sound take group " << i << " in file " << cFilename << endl;
			return false;
		}
		lSoundTakeGroups.push_back(stg);
	}
	
	//Read in the takes
	fseek(f, smh.takes.offset, SEEK_SET);
	vector<takeRecord> vSoundTakes;
	for(i32 i = 0; i < smh.takes.count; i++)
	{
		takeRecord tr;
		if(fread(&tr, 1, sizeof(takeRecord), f) != sizeof(takeRecord))
		{
			cout << "Error reading take record " << i << " in file " << cFilename << endl;
			return false;
		}
		vSoundTakes.push_back(tr);
	}
	
	//Close this file
	fclose(f);
	
	//Done reading the file. Now parse it out to XML
	XMLDocument* doc = new XMLDocument;
	XMLElement* root = doc->NewElement("soundmanifest");	//Create the root element
	root->SetAttribute("numsounds", lSoundTakeGroups.size());
	root->SetAttribute("numtakes", vSoundTakes.size());
	
	//ofstream ofile("soundmanifest_out.txt");
	for(list<soundTakeGroup>::iterator i = lSoundTakeGroups.begin(); i != lSoundTakeGroups.end(); i++)
	{
		XMLElement* elem = doc->NewElement("sound");
		//elem->SetAttribute("id", i->logicalId);
		//Now insert takes for this sound
		for(int j = i->firstTakeIdx; j < i->firstTakeIdx + i->numTakes; j++)
		{
			XMLElement* elem2 = doc->NewElement("take");
			wstring sFilename = getName(vSoundTakes[j].resId);
			//Set the sound resource's ID to be correct
			if(j == i->firstTakeIdx)
				elem->SetAttribute("id", ws2s(getNameFromSoundString(sFilename)).c_str());
			//else if(i->numTakes == 1)
			//	elem->SetAttribute("filename", sFilename.c_str());
			sFilename += TEXT(".ogg");
			elem2->SetAttribute("filename", ws2s(sFilename).c_str());
			elem2->SetAttribute("channels", vSoundTakes[j].channels);
			elem2->SetAttribute("samplespersec", vSoundTakes[j].samplesPerSec);
			elem2->SetAttribute("samplecountperchannel", vSoundTakes[j].sampleCountPerChannel);
			elem2->SetAttribute("vorbisworkingsetsizebytes", vSoundTakes[j].vorbisWorkingSetSizeBytes);
			elem2->SetAttribute("vorbismarkerssizebytes", vSoundTakes[j].vorbisMarkersSizeBytes);
			elem2->SetAttribute("vorbispacketssizebytes", vSoundTakes[j].vorbisPacketsSizeBytes);
			//Add this element
			elem->InsertEndChild(elem2);
		}
		root->InsertEndChild(elem);
		g_mSoundIDToString[i->logicalId] = s2ws(elem->Attribute("id"));	//Save mapping
		g_mStringToSoundID[s2ws(elem->Attribute("id"))] = i->logicalId;	//And reverse mapping
		//ofile << "{" << i->logicalId << "u, \"" << elem->Attribute("filename") << "\"}," << endl;
	}
	//ofile.close();
	
	doc->InsertFirstChild(root);
	wstring sFilename = cFilename;
	sFilename += TEXT(".xml");
	doc->SaveFile(ws2s(sFilename).c_str());
	
	delete doc;
	
	return true;
}

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);
//.........这里部分代码省略.........

void
SettingsPersistence::storeSettings() {
  XMLDocument doc;
  XMLNode* root{doc.NewElement("xml")};
  doc.InsertFirstChild(root);

  {
    XMLElement* chunkData{doc.NewElement("chunk_data")};
    root->InsertEndChild(chunkData);

    {
      XMLElement* numberOfChunks{
        doc.NewElement("number_of_chunks_from_middle_to_border")};
      numberOfChunks->SetText(
        chunk_data::NUMBER_OF_CHUNKS_FROM_MIDDLE_TO_BORDER);
      chunkData->InsertEndChild(numberOfChunks);
    }
  }

  {
    XMLElement* graphicsData{doc.NewElement("graphics_data")};
    root->InsertEndChild(graphicsData);

    {
      XMLElement* fps{doc.NewElement("fps")};
      fps->SetText(graphics_data::fps);
      graphicsData->InsertEndChild(fps);
    }

    {
      XMLElement* fullscreen{doc.NewElement("fullScreen")};
      fullscreen->SetText(graphics_data::fullScreen);
      graphicsData->InsertEndChild(fullscreen);
    }

    {
      XMLElement* fov{doc.NewElement("fov")};
      fov->SetText(graphics_data::fov);
      graphicsData->InsertEndChild(fov);
    }
  }

  {
    XMLElement* inputData{doc.NewElement("input_data")};
    root->InsertEndChild(inputData);

    {
      XMLElement* mouseSenseX{doc.NewElement("mouseSensitivityX")};
      mouseSenseX->SetText(input_data::mouseSensitivityX);
      inputData->InsertEndChild(mouseSenseX);
    }

    {
      XMLElement* mouseSenseY{doc.NewElement("mouseSensitivityY")};
      mouseSenseY->SetText(input_data::mouseSensitivityY);
      inputData->InsertEndChild(mouseSenseY);
    }
  }

  {
    XMLElement* audio{doc.NewElement("audio")};
    root->InsertEndChild(audio);

    {
      XMLElement* maserVolume{doc.NewElement("master_volume")};
      maserVolume->SetText(audio::maserVolume);
      audio->InsertEndChild(maserVolume);
    }

    {
      XMLElement* soundVolume{doc.NewElement("sound_volume")};
      soundVolume->SetText(audio::soundVolume);
      audio->InsertEndChild(soundVolume);
    }

    {
      XMLElement* musicVolume{doc.NewElement("music_volume")};
      musicVolume->SetText(audio::musicVolume);
      audio->InsertEndChild(musicVolume);
    }
  }

  XMLError errorCode{doc.SaveFile(settingsFile.c_str())};
  if (errorCode != 0) {
    cout << "Could not save settings xml file. \n";
    return;
  }
}

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);
//.........这里部分代码省略.........