コード例 #1
0
ファイル: NppFTP.cpp プロジェクト: bycn82/NppFTP
int NppFTP::LoadSettings() {
	int result = 0;

	char xmlPath[MAX_PATH];
	char * utf8Store = SU::TCharToCP(m_configStore, CP_ACP);
	strcpy(xmlPath, utf8Store);
	::PathCombineA(xmlPath, utf8Store, "NppFTP.xml");

	TiXmlDocument settingsDoc = TiXmlDocument(xmlPath);
	settingsDoc.LoadFile();

	strcpy(xmlPath, utf8Store);
	::PathCombineA(xmlPath, utf8Store, "Certificates.xml");
	SU::FreeChar(utf8Store);

	TiXmlDocument certificatesDoc = TiXmlDocument(xmlPath);
	certificatesDoc.LoadFile();

	TiXmlElement* ftpElem = settingsDoc.FirstChildElement("NppFTP");
	if (!ftpElem) {
		result = 1;
		return result;
	}

	m_ftpSettings->LoadSettings(ftpElem);

	TiXmlElement * profilesElem = ftpElem->FirstChildElement(FTPProfile::ProfilesElement);
	if (!profilesElem) {
		m_profiles.clear();
		result = 1;
	} else {
		m_profiles = FTPProfile::LoadProfiles(profilesElem);
		for(size_t i = 0; i < m_profiles.size(); i++) {
			m_profiles.at(i)->AddRef();
			m_profiles.at(i)->SetCacheParent(m_ftpSettings->GetGlobalCache());
		}
	}


	ftpElem = certificatesDoc.FirstChildElement("NppFTP");
	if (!ftpElem) {
		m_certificates.clear();
		result = 1;
	} else {
		TiXmlElement * dersElem = ftpElem->FirstChildElement(SSLCertificates::DERsElem);
		if (!dersElem) {
			m_certificates.clear();
			result = 1;
		} else {
			vDER derVect = SSLCertificates::LoadDER(dersElem);
			m_certificates = SSLCertificates::ConvertDERVector(derVect);
			SSLCertificates::FreeDERVector(derVect);
		}
	}

	return result;
}
コード例 #2
0
ファイル: NNXML.cpp プロジェクト: SlowT/CSM
NNXML::NNXML( std::string path )
	: m_LoadSuccess(false)
{
	m_Document = TiXmlDocument( path.c_str() );
	//m_Document.LoadFile(TIXML_ENCODING_UTF8);
	m_LoadSuccess = m_Document.LoadFile();
}
コード例 #3
0
ファイル: Progress.cpp プロジェクト: danishcake/ShokoTD
Progress::Progress(void)
{
	Logger::DiagnosticOut() << "Loading progress record\n";
	//Load XML
	TiXmlDocument doc = TiXmlDocument("Progress.xml");
	doc.LoadFile();
	TiXmlElement* root = doc.FirstChildElement("Progress");
	if(root)
	{
		TiXmlElement* record = root->FirstChildElement("Record");
		int record_number = 0;
		while(record)
		{
			std::string filename = "";
			bool completed = false;
			bool error = false;
			error |= (record->QueryValueAttribute("Filename", &filename) != TIXML_SUCCESS);
			error |= (record->QueryValueAttribute("Completed", &completed) != TIXML_SUCCESS);
			if(error)
				Logger::DiagnosticOut() << "Error parsing record number: " << record_number << ". Possible data: Filename:" << filename << ", completed: " << completed << "\n";
			else
			{
				ProgressRecord pr;
				pr.completed = completed;
				progress_[filename] = pr;
			}
			record = record->NextSiblingElement("Record");
			record_number++;
		}
	}
}
コード例 #4
0
ファイル: xml.cpp プロジェクト: jacquelinekay/reveal
//-----------------------------------------------------------------------------
bool xml_c::read( std::string filename ) {
  // TODO: robust error checking

  TiXmlDocument doc;
  doc = TiXmlDocument( filename );
  
  bool result;
  result = doc.LoadFile();
  if( !result ) {
    return false;
  }

  TiXmlHandle tixml_hdoc( &doc );
  TiXmlHandle tixml_root( 0 ); 
  TiXmlElement* tixml_e;
  TiXmlHandle tixml_h( 0 );

  tixml_e = tixml_hdoc.FirstChildElement().Element();
  tixml_root = TiXmlHandle( tixml_e );

  _root = xml_element_ptr( new xml_element_c() );
  process_tixml_element( (void*)tixml_e, _root );

  return true;
}
コード例 #5
0
	void SettingsXML::Start(){
		//Load the XML
		_File = TiXmlDocument();
		 TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "", "" );  
		_File.LinkEndChild( decl );
		TiXmlElement * root = new TiXmlElement( "Settings" );  
		_File.LinkEndChild( root );  
	}
コード例 #6
0
WindowUser::WindowUser(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::WindowUser)
{
    ui->setupUi(this);
    doc= TiXmlDocument("Mis Vuelos.xml") ;
     mc= TiXmlDocument("Mis Conexiones.xml") ;


    //connect(this->draw,SIGNAL(MousePos()),this,SLOT(Mouse_Current_Pos()));
    this->setAirport();
     this->ReadXML();





}
コード例 #7
0
void ObjectLoader::setFile(string fileName)
{
	// Set XML file and create the Tiny XML document object
	mFile = fileName;
	mXmlFile = TiXmlDocument(fileName.c_str());

	// Important to load the file!
	mXmlFile.LoadFile();
}
コード例 #8
0
ファイル: XML.cpp プロジェクト: Sonophoto/Soar-SC
  void XML_Document::create_root(const String &field) {
    delete m_root;
    m_root = 0;

    m_xml_file = TiXmlDocument();

    m_xml_file.LinkEndChild(new TiXmlDeclaration("1.0", "", ""));
    m_xml_file.LinkEndChild(new TiXmlElement(field.c_str()));

    TiXmlHandle root = &m_xml_file;
    m_root = new XML_Element(root);
  }
コード例 #9
0
cliente::cliente(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::cliente)
{
    ui->setupUi(this);

    this->a = new miWidget(this);
    a->setGeometry(20,130,900,431);
    a->show();

    doc=TiXmlDocument("Aeropuertos.xml");
    doc2=TiXmlDocument("Conexiones.xml");

    leerXml();
    leerXml2();

    cout<<this->miGrafo.p->ciudad.toStdString();

    miGrafo.mostrar_grafo();

  //  miGrafo.llenarMatriz();

   }
コード例 #10
0
ファイル: sdxmlfile.cpp プロジェクト: mildrock/dummy
	BOOL CSDXMLFile::LoadData(const CHAR* pszData, const UINT32 dwDataLen)
	{
		if(NULL == pszData)
		{
			return FALSE;
		}
		UnLoad();
		m_pDocument = SDNew TiXmlDocument();
		if(m_pDocument->LoadData(pszData, dwDataLen))
		{
			return TRUE;
		}		
		UnLoad();
		return FALSE;
	}
コード例 #11
0
ファイル: sdxmlfile.cpp プロジェクト: mildrock/dummy
    BOOL CSDXMLFile::Load(const CHAR* pszXmlFile)
    {
		if(NULL == pszXmlFile)
		{
			return FALSE;
		}
        UnLoad();
        m_pDocument = SDNew TiXmlDocument();
        if(pszXmlFile!=NULL)
        {
            if(m_pDocument->LoadFile(pszXmlFile))
            {
                return TRUE;
            }
        }
        UnLoad();
        return FALSE;
    }
コード例 #12
0
ファイル: Progress.cpp プロジェクト: danishcake/ShokoTD
Progress::~Progress(void)
{
	Logger::DiagnosticOut() << "Saving progress record\n";
	//Save XML
	TiXmlDocument doc = TiXmlDocument("Progress.xml");
	TiXmlDeclaration* decl = new TiXmlDeclaration();
	TiXmlElement* root = new TiXmlElement("Progress");
	doc.LinkEndChild(decl);
	doc.LinkEndChild(root);
	std::pair<std::string, ProgressRecord> item;
	BOOST_FOREACH(item, progress_)
	{
		TiXmlElement* record = new TiXmlElement("Record");
		record->SetAttribute("Filename", item.first);
		record->SetAttribute("Completed", item.second.completed);

		root->LinkEndChild(record);
	}
コード例 #13
0
void FindingElementDepthTest::setUp() {
	m_tag_father = Tag("portals");
	m_tag_son = Tag("localDatabase");
	m_tag_son_of_son = Tag("name");

	m_invalid_tag_father = Tag("modalities");
	m_invalid_tag_son = Tag("modality");
	m_invalid_tag_son_of_son = Tag("password");

	m_tag_son_value = "localDatabase";
	m_tag_son_of_son_value = "name";
	m_tag_son_of_son_text = "Dicomizer Local Database";

	m_tag_son_with_attributes = Tag("portal");
	m_tag_son_with_attributes.properties["id"] = "hu";

	m_invalid_tag_son_with_attributes = Tag("portal");
	m_invalid_tag_son_with_attributes.properties["id"] = "wrongid";

	m_tag_son_of_son_with_attributes = Tag("databaseName");

	m_tag_son_of_son_with_attributes_value = "databaseName";
	m_tag_son_of_son_with_attributes_text = "telemedicina2";

	m_first_tag_son_of_son_with_attributes_value
			= m_tag_son_of_son_with_attributes_value;
	m_first_tag_son_of_son_with_attributes_text
			= m_tag_son_of_son_with_attributes_text;

	m_tag_son_without_attributes = Tag("portal");

	m_searcher = XmlSearcher();

	m_doc = TiXmlDocument();
	m_doc.LoadFile("test.xml");
}
コード例 #14
0
ファイル: RMxmlLoader.cpp プロジェクト: superhakgoman/oldboy
HRESULT CRMxmlLoader::LoadMusicData(const std::string& folderName )
{
	std::string filePath;
	filePath.append("./Music/");
	filePath.append( folderName );
	filePath.append("/index.xml");
	TiXmlDocument document = TiXmlDocument( filePath.c_str() );

	// document.LoadFile(TIXML_ENCODING_UTF8);
	bool m_LoadSuccess = document.LoadFile();

	std::string title;
	std::string artist;
	std::string level;
	std::string imageAlbum;
	std::string imageBackground;
	std::string imageShutter;
	std::string imageNote1;
	std::string imageNote2;
	std::string imageNoteEffect;
	std::string soundBackground;
	std::string soundNoteEffect1;
	std::string soundNoteEffect2;

	std::string note;


	if ( m_LoadSuccess )
	{

		title = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Title/text()").c_str();
		artist = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Artist/text()").c_str();
		level = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Level/text()").c_str();

		imageAlbum = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageAlbum/text()").c_str();
		imageBackground = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageBackground/text()").c_str();
		imageShutter = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageShutter/text()").c_str();
		imageNote1 = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageNote1/text()").c_str();
		imageNote2 = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageNote2/text()").c_str();
		imageNoteEffect = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Image/imageNoteEffect/text()").c_str();

		soundBackground = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Sound/soundBackground/text()").c_str();
		soundNoteEffect1 = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Sound/soundNoteEffect1/text()").c_str();
		soundNoteEffect2 = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Sound/soundNoteEffect2/text()").c_str();

		note = TinyXPath::S_xpath_string(document.RootElement(), "/Music/Note/text()").c_str();

		printConsole("Loaded Music :%s \n", title.c_str());
		
	}

	if ( title == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_TITLE, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( artist == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_ARTIST, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( level == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_LEVEL, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageAlbum == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_ALBUM, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageBackground == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_BACKGROUND, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageShutter == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_SHUTTER, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageNote1 == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_NOTE1, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageNote2 == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_NOTE2, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( imageNoteEffect == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_IMAGE_NOTE_EFFECT, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( soundBackground == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_SOUND_BACKGROUND, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( soundNoteEffect1 == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_SOUND_NOTE_EFFECT1, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( soundNoteEffect2 == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_SOUND_NOTE_EFFECT2, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}
	else if ( note == "" )
	{
		MessageBox( NULL, ERROR_MESSAGE_LOAD_XML_NOTE_DATA, ERROR_TITLE_LOAD, MB_OK | MB_ICONSTOP );
		return S_FALSE;
	}

	auto& toBeDelete = m_MusicDataMap[folderName];
	SafeDelete( toBeDelete );
	m_MusicDataMap[folderName] = new CRMmusicData();
	
	m_MusicDataMap[folderName]->SetTitle( title );
	m_MusicDataMap[folderName]->SetArtist( artist );
	m_MusicDataMap[folderName]->SetLevel( level );
	m_MusicDataMap[folderName]->SetImageAlbum( imageAlbum );
	m_MusicDataMap[folderName]->SetImageBackground( imageBackground );
	m_MusicDataMap[folderName]->SetImageShutter( imageShutter );
	m_MusicDataMap[folderName]->SetImageNote1( imageNote1 );
	m_MusicDataMap[folderName]->SetImageNote2( imageNote2 );
	m_MusicDataMap[folderName]->SetImageNoteEffect( imageNoteEffect );
	m_MusicDataMap[folderName]->SetSoundBackground( soundBackground );
	m_MusicDataMap[folderName]->SetSoundNoteEffect1( soundNoteEffect1 );
	m_MusicDataMap[folderName]->SetSoundNoteEffect2( soundNoteEffect2 );
	m_MusicDataMap[folderName]->SetNote( note );

	return S_OK;

}
コード例 #15
0
ファイル: NNXML.cpp プロジェクト: SlowT/CSM
NNXML::NNXML()
{
	m_Document = TiXmlDocument();
}
コード例 #16
0
bool AutoCompletion::setLanguage(LangType language) {
	if (_curLang == language)
		return true;
	_curLang = language;

	TCHAR path[MAX_PATH];
	//::GetModuleFileName(NULL, path, MAX_PATH);
	//PathRemoveFileSpec(path);
	CString strOwmPath = theApp.GetModulePath();
	lstrcpy(path, strOwmPath);
	lstrcat(path, TEXT("\\APIs\\"));
	lstrcat(path, getApiFileName());
	lstrcat(path, TEXT(".xml"));

	_XmlFile = TiXmlDocument(path);
	_funcCompletionActive = _XmlFile.LoadFile();

	TiXmlNode * pAutoNode = NULL;
	if (_funcCompletionActive) {
		_funcCompletionActive = false;	//safety
		TiXmlNode * pNode = _XmlFile.FirstChild(TEXT("OwmScite"));
		if (!pNode)
			return false;
		pAutoNode = pNode = pNode->FirstChildElement(TEXT("AutoComplete"));
		if (!pNode)
			return false;
		pNode = pNode->FirstChildElement(TEXT("KeyWord"));
		if (!pNode)
			return false;
		_pXmlKeyword = reinterpret_cast<TiXmlElement *>(pNode);
		if (!_pXmlKeyword)
			return false;
		_funcCompletionActive = true;
	}

	if(_funcCompletionActive) {	//try setting up environment
		//setup defaults
		_ignoreCase = true;
		_funcCalltip._start = '(';
		_funcCalltip._stop = ')';
		_funcCalltip._param = ',';
		_funcCalltip._terminal = ';';
		_funcCalltip._ignoreCase = true;

		TiXmlElement * pElem = pAutoNode->FirstChildElement(TEXT("Environment"));
		if (pElem) {	
			const TCHAR * val = 0;
			val = pElem->Attribute(TEXT("ignoreCase"));
			if (val && !lstrcmp(val, TEXT("no"))) {
				_ignoreCase = false;
				_funcCalltip._ignoreCase = false;
			}
			val = pElem->Attribute(TEXT("startFunc"));
			if (val && val[0])
				_funcCalltip._start = val[0];
			val = pElem->Attribute(TEXT("stopFunc"));
			if (val && val[0])
				_funcCalltip._stop = val[0];
			val = pElem->Attribute(TEXT("paramSeparator"));
			if (val && val[0])
				_funcCalltip._param = val[0];
			val = pElem->Attribute(TEXT("terminal"));
			if (val && val[0])
				_funcCalltip._terminal = val[0];
		}
	}

	if (_funcCompletionActive) {
		_funcCalltip.setLanguageXML(_pXmlKeyword);
	} else {
		_funcCalltip.setLanguageXML(NULL);
	}

	_keyWords = TEXT("");
	if (_funcCompletionActive) {	//Cache the keywords
		//Iterate through all keywords
		TiXmlElement *funcNode = _pXmlKeyword;
		const TCHAR * name = NULL;
		for (; funcNode; funcNode = funcNode->NextSiblingElement(TEXT("KeyWord")) ) {
			name = funcNode->Attribute(TEXT("name"));
			if (!name)		//malformed node
				continue;
			_keyWords.append(name);
			_keyWords.append(TEXT("\n"));
		}
	}
	return _funcCompletionActive;
}
コード例 #17
0
ファイル: run.cpp プロジェクト: globox1/toaster
    /**
     * Constructor of the run class for toaster_vizualiser
     */
    Run() {
        name_list = std::vector<std::string>();
        id_cpt = 1;

        ros::NodeHandle reception_node;
        ros::NodeHandle emission_node;

        area_list = visualization_msgs::MarkerArray();
        obj_list = visualization_msgs::MarkerArray();
        human_list = visualization_msgs::MarkerArray();
        robot_list = visualization_msgs::MarkerArray();

        //definition of subscribers
        sub_objList = reception_node.subscribe("/pdg/objectList", 1000, &Run::chatterCallbackObjList, this);
        sub_areaList = reception_node.subscribe("/area_manager/areaList", 1000, &Run::chatterCallbackAreaList, this);
        sub_humanList = reception_node.subscribe("/pdg/humanList", 1000, &Run::chatterCallbackHumanList, this);
        sub_robotList = reception_node.subscribe("/pdg/robotList", 1000, &Run::chatterCallbackRobotList, this);

        //definition of publishers
        pub_obj = emission_node.advertise<visualization_msgs::MarkerArray>("/toaster_visualizer/marker_object", 1000);
        pub_area = emission_node.advertise<visualization_msgs::MarkerArray>("/toaster_visualizer/marker_area", 1000);
        pub_human = emission_node.advertise<visualization_msgs::MarkerArray>("/toaster_visualizer/marker_human", 1000);
        pub_robot = emission_node.advertise<visualization_msgs::MarkerArray>("/toaster_visualizer/marker_robot", 1000);


        //open xml files

        // Objects
        std::stringstream pathObj;
        pathObj << ros::package::getPath("toaster_visualizer") << "/src/list_obj.xml";
        listObj = TiXmlDocument(pathObj.str());

        if (!listObj.LoadFile()) {
            ROS_WARN_ONCE("Erreur lors du chargement du fichier xml");
            ROS_WARN_ONCE("error # %d", listObj.ErrorId());
            ROS_WARN_ONCE("%s", listObj.ErrorDesc());
        }

        // Humans
        std::stringstream pathHuman;
        pathHuman << ros::package::getPath("toaster_visualizer") << "/src/list_human_morse_joints.xml";
        listMemb = TiXmlDocument(pathHuman.str());

        if (!listMemb.LoadFile()) {
            ROS_WARN_ONCE("Erreur lors du chargement du fichier xml");
            ROS_WARN_ONCE("error # %d", listMemb.ErrorId());
            ROS_WARN_ONCE("%s", listMemb.ErrorDesc());
        }

        // Robots        
        /*path.flush();
        path << ros::package::getPath("toaster_visualizer") << "/src/list_robots.xml";
        listRob = TiXmlDocument(path.str());

        if (!listRob.LoadFile()) {
            ROS_WARN_ONCE("Erreur lors du chargement du fichier xml");
            ROS_WARN_ONCE("error # %d", listRob.ErrorId());
            ROS_WARN_ONCE("%s", listRob.ErrorDesc());
        }*/

    }
コード例 #18
0
ファイル: Automata.cpp プロジェクト: Turupawn/DemoFlatShooter
void Automata::loadFromXML(string archivo,string archivo_default)
{
    TiXmlDocument doc_t(archivo.c_str());
    bool loadOkay = doc_t.LoadFile();
    if(!loadOkay)
    {
        doc_t=TiXmlDocument(archivo_default.c_str());
        loadOkay=doc_t.LoadFile();
        cout.flush();
    }
    TiXmlDocument *doc;
    doc=&doc_t;

    for(TiXmlNode* nodo=doc->FirstChild("State");
            nodo!=NULL;
            nodo=nodo->NextSibling("State"))
    {
        std::vector<Transicion*> transiciones;
        for(TiXmlElement *e_action=nodo->FirstChild("Action")->ToElement();
                e_action!=NULL;
                e_action=e_action->NextSiblingElement("Action"))
        {
            Transicion *transicion;
            if(e_action->Attribute("rewardable")!=NULL)
                transicion=new Transicion(e_action->Attribute("input"),e_action->Attribute("destination"),strcmp(e_action->Attribute("rewardable"),"yes")==0);
            else
                transicion=new Transicion(e_action->Attribute("input"),e_action->Attribute("destination"),false);
            if(e_action->Attribute("reward")!=NULL)
                transicion->setRecompensa(atoi(e_action->Attribute("reward")));
            if(e_action->Attribute("wait")!=NULL)
                transicion->setWait(atoi(e_action->Attribute("wait")));




            if(e_action->FirstChild("condition")!=NULL)
            {
                for(TiXmlElement *elemento_condicion=e_action->FirstChild("condition")->ToElement();
                        elemento_condicion!=NULL;
                        elemento_condicion=elemento_condicion->NextSiblingElement("condition"))
                {
                    std::string exp_i(elemento_condicion->Attribute("left_exp"));
                    std::string op(elemento_condicion->Attribute("relational_op"));
                    std::string exp_d(elemento_condicion->Attribute("right_exp"));
                    std::string str_contrario(elemento_condicion->Attribute("to_opponent"));
                    bool contrario=(str_contrario=="yes");
                    transicion->agregarCondicion(Condicion2(exp_i,op,exp_d,contrario));
                }
            }

            if(e_action->FirstChild("condition_integer")!=NULL)
            {
                for(TiXmlElement *elemento_condicion=e_action->FirstChild("condition_integer")->ToElement();
                        elemento_condicion!=NULL;
                        elemento_condicion=elemento_condicion->NextSiblingElement("condition_integer"))
                {
                    std::string exp_i(elemento_condicion->Attribute("left_exp"));
                    std::string op(elemento_condicion->Attribute("relational_op"));
                    int exp_d=atoi(elemento_condicion->Attribute("right_exp"));
                    std::string str_contrario(elemento_condicion->Attribute("to_opponent"));
                    bool contrario=(str_contrario=="yes");
                    transicion->agregarCondicion(Condicion2(exp_i,op,exp_d,contrario));
                }
            }
            transiciones.push_back(transicion);
        }
        estados[std::string(nodo->ToElement()->Attribute("name"))]=new Estado(transiciones);
    }
}
コード例 #19
0
ファイル: parse_xml.cpp プロジェクト: utwente-fmt/sigrefmc
SystemParser::SystemParser(const char* filename, unsigned int verbosity, LeafType leaf_type)
{
    // Open the document
    TiXmlDocument document = TiXmlDocument(filename);
    if (!document.LoadFile()) {
        throw ParseError("[ERROR] Could not load the input file.");
    }

    // Get the root node of the XML-document
    TiXmlNode* rootNode = document.RootElement();
    if (rootNode == NULL) {
        throw ParseError("[ERROR] Could not access the root node of the XML-tree");
    }

    // Find out the type of the transition system (lts, ctmc, imc)
    const std::string type_str = readStringAttribute(rootNode, "type");
    if (type_str == "lts") system_type = lts_type;
    else if (type_str == "ctmc") system_type = ctmc_type;
    else if (type_str == "imc") system_type = imc_type;
    else system_type = lts_type;

    this->leaf_type = leaf_type;

    // Traverse the children of the root node and collect the pointers to the parts we need.
    TiXmlNode* varinfoNode = NULL;
    TiXmlNode* initialstateNode = NULL;
    TiXmlNode* transNode = NULL;
    TiXmlNode* markovtransNode = NULL;
    TiXmlNode* initialpartitionNode = NULL;
    TiXmlNode* tauNode = NULL;

    for (TiXmlNode* currentNode = rootNode->FirstChild();
         currentNode != NULL;
         currentNode = currentNode->NextSibling()) {

        if (currentNode->ToElement() == NULL) continue;

        const char* const name = currentNode->ToElement()->Value();

        if (strcmp(name, "variables") == 0) {
            varinfoNode = currentNode;
        } else if (strcmp(name, "dd") == 0) {
            std::string bdd_type = readStringAttribute(currentNode, "type");
            if (bdd_type == "initial_state") {
                initialstateNode = currentNode;
            } else if (bdd_type == "trans") {
                transNode = currentNode;
            } else if (bdd_type == "markov_trans") {
                markovtransNode = currentNode;
            } else if (bdd_type == "tau") {
                tauNode = currentNode;
            }
        } else if (strcmp(name, "initial_partition") == 0) {
            initialpartitionNode = currentNode;
        }
    }

    // Check if we have found the variable information
    if (varinfoNode == NULL) {
        throw ParseError("[ERROR] No variable information found!");
    }

    // Check if the correct information exists for the system type
    switch (system_type) {
    case lts_type:
        if (markovtransNode != NULL) {
            throw ParseError("[ERROR] LTS must not have any Markov transitions!");
        }
        if (transNode == NULL) {
            throw ParseError("[ERROR] LTS must have an interactive transition relation!");
        }
        break;
    case ctmc_type:
        if (transNode != NULL) {
            throw ParseError("[ERROR] CTMCs must not have any interactive transitions!");
        }
        if (markovtransNode == NULL) {
            throw ParseError("[ERROR] CTMCs must have a Markov transition relation!");
        }
        break;
    case imc_type:
        if (transNode == NULL) {
            throw ParseError("[ERROR] IMCs must have an interactive transition relation!");
        }
        if (markovtransNode == NULL) {
            throw ParseError("[ERROR] IMCs must have a Markov transition relation!");
        }
        break;
    }

        // Parse the variable information and create the BDD variables
        // together with an appropriate order for refinement
        if (verbosity > 0) std::cout << "[INFO] Creating BDD variables ... " << std::flush;
        createVariables(varinfoNode);
        if (verbosity > 0) std::cout << "finished." << std::endl;

        // Build the BDDs/ADDs for all parts
        if (verbosity > 0) std::cout << "[INFO] Building BDDs ... " << std::flush;

        std::vector<std::pair<Bdd, Bdd>> transitions;
        Bdd _transitions = Bdd::bddZero();
        if (transNode != NULL) {
            _transitions = nodeToBdd(transNode);
            transitions.push_back(std::make_pair(_transitions, varS * varT));
        }

        Mtbdd markov_transitions;
        if (markovtransNode != NULL) markov_transitions = nodeToMtbdd(markovtransNode);

        Bdd tau;
        if (tauNode != NULL) tau = nodeToBdd(tauNode);
        else {
            // Default value of tau: 0
            int action_bits = sylvan_set_count(varA.GetBDD());
            std::vector<uint8_t> tau_value;
            for (int i=0; i<action_bits; i++) tau_value.push_back(0);
            tau = Bdd::bddCube(varA, tau_value);
        }

        Bdd initial_state;
        if (initialstateNode != NULL) initial_state = nodeToBdd(initialstateNode);

        Bdd states = computeStateSpace(_transitions, markov_transitions);

        std::vector<Bdd> initial_partition;
        if (initialpartitionNode != NULL) {
            for (TiXmlNode* currentNode = initialpartitionNode->FirstChild();
                 currentNode != NULL; currentNode = currentNode->NextSibling()) {
                initial_partition.push_back(nodeToBdd(currentNode));
            }
        }
        if (initial_partition.size() == 0) initial_partition.push_back(states);
        if (verbosity > 0) std::cout << "finished." << std::endl;

        // Fill the right system with information
        switch (system_type) {
        case lts_type:
            lts.transitions = transitions;
            lts.states = states;
            lts.tau = tau;
            lts.initialStates = initial_state;
            lts.initialPartition = initial_partition;
            lts.varS = varS;
            lts.varT = varT;
            lts.varA = varA;
            break;

        case imc_type:
            imc.transitions = transitions;
            imc.markov_transitions = markov_transitions;
            imc.states = states;
            imc.tau = tau;
            imc.initialStates = initial_state;
            imc.initialPartition = initial_partition;
            imc.varS = varS;
            imc.varT = varT;
            imc.varA = varA;
            break;

        case ctmc_type:
            ctmc.markov_transitions = markov_transitions;
            ctmc.states = states;
            ctmc.initialStates = initial_state;
            ctmc.initialPartition = initial_partition;
            ctmc.varS = varS;
            ctmc.varT = varT;
            break;

        default:
            break;
        }
}
コード例 #20
0
ファイル: RMxmlLoader.cpp プロジェクト: superhakgoman/oldboy
HRESULT CRMxmlLoader::LoadNoteData( const std::string& folderName )
{
	std::string filePath;
	filePath.append("./Music/");
	filePath.append( folderName );
	filePath.append("/");
	filePath.append( m_MusicDataMap[folderName]->GetNote() );

	TiXmlDocument document = TiXmlDocument( filePath.c_str() );

	bool m_LoadSuccess = document.LoadFile();

	if ( m_LoadSuccess )
	{
		if ( m_NoteList.size() > 0 )
		{
			for ( auto& toBeDelete : m_NoteList )
			{
				SafeDelete( toBeDelete );
			}
		}

		m_NoteList.clear();

		TiXmlNode* node = document.FirstChild("Notes")->FirstChild("Note");
		while ( node != NULL )
		{
			int time = 0;
			int level = 0;
			node->ToElement()->Attribute("time", &time);
			node->ToElement()->Attribute("level", &level);
			std::string type = node->ToElement()->GetText();


			CRMnoteData* noteData = new CRMnoteData (time, level, (type == "left") ? OBJECT_NOTE_NORMAL_1 : OBJECT_NOTE_NORMAL_2 );
			m_NoteList.push_back( noteData );
			node = node->NextSibling();
		}

		/*

		TiXmlNode* node = document.FirstChild("Notes");

		int	bpm = 0;
		if ( node != NULL )
		{
			node->ToElement()->Attribute("bpm", &bpm);
		}

		node = document.FirstChild("End");

		int endTime = 0;
		if ( node != NULL )
		{
			node->ToElement()->Attribute("time", &endTime);
		}

		node = document.FirstChild("Notes")->FirstChild("Note");

		int level = 0;

		int beat1Time = 0;
		int nextTime = 0;

		int endJoint = 0;
		int jointCount = 0;

		std::string type;
		CRMnoteData* noteData = nullptr;

		while ( node != NULL && nextTime < endTime)
		{
			node->ToElement()->Attribute("start", &beat1Time);
			node->ToElement()->Attribute("end", &endJoint);
			type = node->ToElement()->GetText();

			nextTime = beat1Time + ( 1000 * 60 / bpm );

			jointCount = 0;

			if ( type == "on" )
			{
				while ( beat1Time < endJoint )
				{
					printConsole ( "%d밀리초에 노트 하나 추가요~! \n", (beat1Time + (jointCount * 60 / bpm) - 2152) );

					noteData = new CRMnoteData( (beat1Time + (jointCount * 60 / bpm) - 2152) , (jointCount % 2) + 1 , (jointCount++ % 2 == 0) ? OBJECT_NOTE_NORMAL_1 : OBJECT_NOTE_NORMAL_2 );
					// 2152 = 화면 최상단에서 판정판까지 내려오기까지 걸리는 시간 ms
					m_NoteList.push_back( noteData );

					beat1Time += 1000 * 60 / bpm;
				}
			}

			node = node->NextSibling();
		}
		*/
	}
	
	if ( m_NoteList.size() == 0 )
	{
		return S_FALSE;
	}

	return S_OK;
}
コード例 #21
0
ファイル: NNXML.cpp プロジェクト: SlowT/CSM
NNXML::NNXML( char *buf )
{
	m_Document = TiXmlDocument();
	//m_Document.LoadFile(TIXML_ENCODING_UTF8);
	m_Document.Parse( buf );
}
コード例 #22
0
void IPXMLParser::parseXML() {
    if ( fileName.empty() )
        throw std::runtime_error( "Exception: fileName.empty()" );

    doc = TiXmlDocument( fileName );

    if ( !doc.LoadFile() )
        throw std::runtime_error( "Exception: XML file cannot be loaded!" );

    std::cout << fileName << " opened successfully!\n";

    TiXmlHandle hDoc( &doc );
    TiXmlHandle hRoot( NULL );

    el = hDoc.FirstChildElement( "Properties" ).ToElement();

    if ( !el )
        throw std::runtime_error(
                "Exception: XML file empty or 'Properties' missing!" );

    hRoot = TiXmlHandle( el );

    TiXmlElement * properties = hRoot.FirstChild( "Property" ).ToElement();

    if ( !properties )
        throw std::runtime_error( "Exception: 'Properties' is empty!" );

    for ( ; properties;
            properties = properties->NextSiblingElement( "Property" ) ) {
        const char * elName = properties->Attribute( "name" );

        if ( !properties )
            throw std::runtime_error( "Exception: no element named Property!" );

        if ( strcmp( elName, "hsvMin" ) != 0
                && std::strcmp( elName, "hsvMax" ) != 0 )
            throw std::runtime_error(
                    "Exception: hsvMin and hsvMax not available!" );

        if ( strcmp( elName, "hsvMin" ) == 0 ) {
            double hMin, sMin, vMin;

            properties->QueryDoubleAttribute( "hMin", &hMin );
            properties->QueryDoubleAttribute( "sMin", &sMin );
            properties->QueryDoubleAttribute( "vMin", &vMin );

            hsvMin = cv::Scalar( hMin, sMin, vMin );

            std::cout << "hsvMin: " << hsvMin( 0 ) << " " << hsvMin( 1 ) << " "
                    << hsvMin( 2 ) << " " << hsvMin( 3 ) << std::endl;
        }

        if ( strcmp( elName, "hsvMax" ) == 0 ) {
            double hMax, sMax, vMax;

            properties->QueryDoubleAttribute( "hMax", &hMax );
            properties->QueryDoubleAttribute( "sMax", &sMax );
            properties->QueryDoubleAttribute( "vMax", &vMax );

            hsvMax = cv::Scalar( hMax, sMax, vMax );

            std::cout << "hsvMax: " << hsvMax( 0 ) << " " << hsvMax( 1 ) << " "
                    << hsvMax( 2 ) << " " << hsvMax( 3 ) << std::endl;
        }
    }
}