Parser des fichiers XML avec boost

Version imprimable

25/02/2010, 14h21
K-you

Parser des fichiers XML avec boost

Bonjour,

Je développe actuellement un programme C++ manipulant des fichiers XML. Je génère donc mes fichiers XML constitués des informations présentes dans mes objets C++.

Je voudrais aussi pouvoir récupérer des infos d'autres fichiers XML afin de créer de nouvelles instances d'objets C++.

Pour générer le XML j'utilise la librairie boost, et sa sérialization sous forme de fichier XML.

J'ai pu voir sur un tutoriel developpez.com qu'il été possible d'inclure boost::archive:: xml_iarchive par opposition à boost:: archive:: xml_oarchive (utilisé pour la génération XML). Mais je n'ai trouvé aucun exemple sur le parsing avec boost à part avec un autre outil proposé par boost : le boost::spirit qui permet de définir des parseurs (mais là encore peu d'exemple).

Alors Connaissez-vous un moyen de parser du XML avec boost (librairie déjà largement exploitée dans mon projet : thread, mutex,...) ? Quelques exemples simples ne seraient pas de refu.

Salut,
De ce que je comprends du tuto et de l'exemple de la doc boost, c'est quelque chose comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <fstream>
#include <vector>
 
// classe à sérialiser
class Test{
public:
	Test(){}
    Test(int i, std::string c, float f1, float f2){
        a=i;
        s=c;
        v.push_back(f1);
        v.push_back(f2);
    }
 
template<class Archive>
void serialize(Archive& ar, const unsigned int version)
{
     ar & BOOST_SERIALIZATION_NVP(a) &
	 BOOST_SERIALIZATION_NVP(s) &
	 BOOST_SERIALIZATION_NVP(v);
}
    int a;
    std::string s;
    std::vector<float> v;
};
 
 
int main()
{
   { // ecriture
      std::ofstream ofile("archive.xml");
      boost::archive::xml_oarchive oTextArchive(ofile);
      Test t(2, std::string("essai"), 2.0, 3.5);
      oTextArchive << BOOST_SERIALIZATION_NVP(t);    // sérialisation de t
   }
 
   {// lecture
      std::ifstream ifile("archive.xml");
      boost::archive::xml_iarchive iTextArchive(ifile);
      Test t2;
      iTextArchive >> BOOST_SERIALIZATION_NVP(t2);    // sérialisation de t
   }
 
   return 0;
}

En revanche, cela ne sert pas à 'parser' du XML mais à relire un objet sérialiser en XML avec Boost.

25/02/2010, 14h56
Goten

La doc de spirit (surtout en V2) est vraiment exhaustive et comprends notamment l'écriture d'un parser pour du "tinyxml" (un xml simplifié au max) qui pourrait t'aider ;).
25/02/2010, 15h05
3DArchi

Citation:

Envoyé par Goten

La doc de spirit (surtout en V2) est vraiment exhaustive et comprends notamment l'écriture d'un parser pour du "tinyxml" (un xml simplifié au max) qui pourrait t'aider ;).

Pourquoi ne pas partir sur tinyXML alors...
25/02/2010, 15h13
Goten

+1, c'est juste un lapsus révélateur ... La doc de spirit montre un exemple permettant de parser un minixml xD. (simplifié quoi).
Et ouai autant éviter de réinventer la roue, utilise tinyxml.
25/02/2010, 15h14
Mac LAK

Ou sur un wrapper fait via XSD (le générateur, pas le schéma) + Xerces...

J'ai réussi à appliquer le morceau de code du tuto :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
//récupération des infos Action
Action tRecupAction;
    std::ifstream ifile2("action.xml");
    boost::archive::xml_iarchive ia2(ifile2);
    ia2 >> BOOST_SERIALIZATION_NVP(tRecupAction);
	std::cout << std::endl;	
	std::cout <<  tRecupAction.pays << std::endl;
	std::cout <<  tRecupAction.ville << std::endl;   
 
		for(std::vector<int>::iterator itItem = (tRecupAction.date).begin(); 
			itItem!=(tRecupAction.date).end(); itItem++)
		{
				std::cout << (*itItem) << std::endl;
		}

ma classe action

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
// classe à sérialiser
class Action{
 
public:
	std::string pays;
    std::string ville;
    std::vector<int> date;
 
	Action(){}
    Action(std::string p, std::string v, int i1, int i2, int i3){
        pays=p;
        ville=v;
        date.push_back(i1);
        date.push_back(i2);
		date.push_back(i3);
    }
 
private:
 
	friend class boost::serialization::access;
 
	template<class Archive>
	void serialize(Archive& ar, const unsigned int version)
	{
     ar & BOOST_SERIALIZATION_NVP(pays) & 
	 BOOST_SERIALIZATION_NVP(ville) & 
	 BOOST_SERIALIZATION_NVP(date);        
	}
};

mon fichier XML

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE boost_serialization>
 
<boost_serialization signature="serialization::archive" version="5">
  <action class_id="0" tracking_level="0" version="0">
    <pays>france</pays>
    <ville>paris</ville>
    <date>
      <count>3</count>
      <item_version>0</item_version>
      <item>25</item>
      <item>02</item>
	  <item>2010</item>
    </date>
  </action>
</boost_serialization>

Le fichier XML est écrit par mes soins. Il est vrai que j'ai pris soin d'ajouter le doctype boost_serialization, et la balise anglobante

Code:

1
2
 
<boost_serialization signature="serialization::archive" version="5">

Mais pour le reste le fichier XML est standard (il est d'ailleurs généré par du code Java et Jdom), donc boost sert bien de parser XML non ? Ou bien je ne saisi pas la nuance entre parser et déserializer....

Merci pour vos réponses

25/02/2010, 16h44
camboui

Tu ne pourras désérialiser avec boost qu'un fichier préalablement sérialisé avec boost, que se soit une sérialisation en binaire, en texte ou en XML.
Il n'y a pas de parser XML générique dans boost. Mais si tu "triches" en faisant croire à boost qu'un fichier XML a été sérialisé par ses soins, pourquoi pas.
25/02/2010, 17h02
K-you

Ok, je vois. Je pense que je vais "tricher" alors.