Utilisation de la bibliothèque TinyXML

Tout au long de ce document, je vais parler (entre autres) de DOM et de XML. En voici quelques précisions :

Définition du W3C
Le DOM (Document Object Model) définit une méthode standard pour accéder à des données et pour les manipuler. Le DOM représente un document XML sous la forme d'un arbre.

Extrait de l'introduction à XML
XML est l'abréviation de Extensible Markup Language. Contrairement aux « on-dit », XML n'est pas un langage de programmation. On ne peut pas faire de tests ni inclure un fichier dans un autre. En très gros, XML sert uniquement à stocker des données. XML est simplement une méthode pour représenter les données. Celles-ci sont écrites entre des balises ou sous forme d'attributs, et l'ensemble est écrit sous forme d'un arbre.

TinyXML est une bibliothèque Open Source de gestion de fichiers XML. Elle est distribuée sous la licence zlib :

• vous avez le droit d'utiliser, modifier et redistribuer le code source gratuitement ou non ;
• l'origine des sources ne doit pas être masquée ;
• les modifications que vous apportez doivent être clairement visibles pour ne pas entrainer de confusion avec la version originale.

Plus d'infos sur cette licence ici.

TinyXML est utilisable sur les environnements Windows 32 bits, sur tous les systèmes POSIX (BSD, Unix) et sur Linux. Les sources sont disponibles sur le site de développement http://sourceforge.net/projects/tinyxml. TinyXML est également disponible en version précompilée pour MinGW sous forme de DevPack.

La bibliothèque peut être compilée de deux manières, en utilisant ou non la STL, ainsi le DevPack contient un fichier libtinyxml.a et un fichier libtinyxmlstl.a. Dans le cas où vous décidez d'utiliser la version STL, vous devez définir la variable de compilation TIXML_USE_STL, soit par la ligne de commande du compilateur soit en la rajoutant dans le code source de votre application. L'option pour l'édition de liens sera donc elle aussi différente : -ltinyxml ou bien -ltinyxmlstl. Ne vous trompez pas !

Donc pour résumer, pour utiliser TinyXML, il faut

• la compiler avec votre compilateur favori ou bien récupérer une version précompilée ;
• copier tinyxml.h et tinystr.h dans le répertoire include de votre compilateur (ou à tout autre endroit que le compilateur saura trouver) ;
• copier le fichier .a ou .lib (qui dépend si vous utilisez ou non la STL) dans le répertoire lib de votre compilateur (ou à tout autre endroit que le compilateur saura trouver) ;
• lier la bibliothèque dans tous les projets qui l'utiliseront.

L'utilisation de TinyXML est très simple, il suffit de quelques lignes pour récupérer les informations d'un fichier XML. Je vais continuer dans la lancée de mon précédent article sur les serveurs multithreads et orienter mes exemples dans ce sens : je vais présenter les fonctions de gestion des utilisateurs autorisés à accéder à un serveur. Mais soyons d'accord, dans le cas d'une grande liste d'utilisateurs, une solution plus efficace serait d'interroger une base de données.

Je choisis de charger la liste des utilisateurs lors du démarrage du serveur. Notez qu'on pourrait très bien ne rien charger et aller interroger le fichier XML à chaque opération. Chaque utilisateur possède un nom et un mot de passe ainsi qu'un indice définissant ses droits. Le fichier xml que nous avons à gérer a donc la forme suivante :

<?xml version="1.0" encoding="ISO-8859-1"?>
<lstUsers>
    <user name="toto" pass="13" indice="1"/>
    <user name="tata" pass="142" indice="2"/>
    <user name="titi" pass="azerty" indice="1"/>
</lstUsers>

Notre fichier XML possède un nœud « lstUsers » comportant trois enfants, chacun étant un nœud « user ». Et chaque user comporte trois attributs. On pourrait aussi tout à fait imaginer d'autres attributs ou bien une imbrication des informations avec une hiérarchie plus développée, ça ne pose aucun problème.

On commence le programme par inclure le header de la bibliothèque :

#include <tinyxml.h>

Pour simplifier l'écriture et ne pas avoir à écrire std:: devant tous les éléments des bibliothèques standards (voir la FAQ pour plus de précisions) rajoutons la ligne :

using namespace std;

L'une des particularités intéressantes de TinyXML est qu'il reconnaît automatiquement l'encodage d'un fichier XML. Ainsi, il n'est pas nécessaire de renseigner l'attribut « encoding ». Cela vous permettra par exemple d'extraire des données comportant des caractères spéciaux (accents, caractères chinois…). Et dans la série des petits « plus » qui sont agréables à utiliser, on retrouve l'indentation automatique des fichiers XML enregistrés.

II-A. Le chargement du fichier XML▲

TiXmlDocument doc("users.xml");
if(!doc.LoadFile()){
    cerr << "erreur lors du chargement" << endl;
    cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
    return 1;
}

II-B. L'extraction des données▲

class user{
    public:
        string name, pass;
        int droits;
};

list<user> user_list;

TiXmlElement *elem = doc.FirstChildElement()->FirstChildElement();

TiXmlHandle hdl(&doc);
TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();

user cl;
if(!elem){
    cerr << "le nœud à atteindre n'existe pas" << endl;
    return 2;
}
 
while (elem){
    cl.name = elem->Attribute("name");
    cl.pass = elem->Attribute("pass");
    elem->QueryIntAttribute("indice", &cl.droits);
    user_list.push_back(cl);
 
    elem = elem->NextSiblingElement(); // iteration 
}

list<user>::iterator i;
for(i=user_list.begin(); i!=user_list.end(); i++)
    cout << i->name << " " << i->pass << " " << i->droits << endl;

toto 13 1
tata 142 2
titi azerty 1

Pour modifier un utilisateur, il va falloir se positionner correctement dans l'arbre DOM puis changer un ou plusieurs attributs. On va donc boucler sur les utilisateurs jusqu'à trouver celui qui nous intéresse puis on va le changer. Et vous n'oublierez pas de mettre à jour la list<user>.

Je me sers donc d'un booléen pour quitter la boucle de parcours, mon itérateur sera ainsi positionné sur le nœud à modifier. La fonction membre SetAttribute nous permet ensuite de changer la valeur d'un attribut donné. Dans cet exemple, j'ai choisi de changer le mot de passe de l'utilisateur « tata » par « nouv ».

bool trouve = false;
TiXmlHandle hdl(&doc);
TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();
 
while(elem && !trouve){
    if( string(elem->Attribute("name")) == "tata"){
        trouve = true;
        break;
    }
    elem = elem->NextSiblingElement(); // iteration, passage a l'element suivant
}
 
if (!trouve)
    cerr << "user inexistant" << endl;
else{
    elem->SetAttribute("pass", "nouv");
    doc.SaveFile("users.xml");  // enregistrement de la modification
}

Et maintenant un peu plus dur, supprimer des membres dans l'arbre DOM. Mais non, ce n’est pas si difficile, TinyXML fait tout pour vous.

La suppression de nœuds s'effectue de la manière suivante, on boucle sur tous les nœuds frères jusqu'à trouver celui à supprimer. Et ensuite on appelle la fonction de suppression en spécifiant le nœud qui va perdre un fils. Il va donc nous falloir un pointeur sur l'élément à supprimer et un pointeur sur l'élément parent. Tous les deux seront du type TiXmlElement.

Dans cet exemple, nous supprimons l'utilisateur nommé « tata ».

bool trouve = false;
TiXmlHandle hdl(&doc);
TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();
 
while(elem && !trouve){
    if( string(elem->Attribute("name")) == "tata"){
        trouve = true;
        break;
    }
    elem = elem->NextSiblingElement();
}
 
if (!trouve)
    cerr << "user à supprimer inexistant" << endl;
else{
    TiXmlElement *f = doc.FirstChildElement();
    f->RemoveChild(elem);
    doc.SaveFile("users.xml");
}

L'objet *f correspond au nœud <lstUsers>, qui contient le nœud <user>. C'est l'objet parent qui va invoquer la fonction de suppression. Et de même que pour la modification d'un nœud, on enregistre le fichier après la suppression.

Autre opération nécessaire, l'ajout d'un nouvel utilisateur. Deux possibilités, on peut insérer le nouvel élément à la fin de l'arborescence ou bien à un endroit particulier. Je vais traiter les deux cas.

V-A. Ajout à un emplacement précis▲

bool trouve = false;
TiXmlHandle hdl(&doc);
TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();
 
while(elem && !trouve){
    if( string(elem->Attribute("name")) == "tata"){
        trouve = true;
        break;
    }
    elem = elem->NextSiblingElement();
}
 
if (!trouve)
    cerr << "user inexistant" << endl;
else {
    TiXmlElement *f = doc.FirstChildElement(); // on récupère le nœud parent
    TiXmlElement le_nouveau ("user");
    le_nouveau.SetAttribute("name", "tutu");
    le_nouveau.SetAttribute("pass", "le_pass");
    le_nouveau.SetAttribute("rank", "4");
 
    f->InsertAfterChild(elem, le_nouveau);
    doc.SaveFile("users.xml");  // enregistrement des modifications
}

V-B. Ajout en fin d'arborescence▲

TiXmlElement *f = doc.FirstChildElement();
TiXmlElement le_nouveau ("user");
le_nouveau.SetAttribute("name", "tutu");
le_nouveau.SetAttribute("pass", "le_pass");
le_nouveau.SetAttribute("indice", "4");
 
f->InsertEndChild(le_nouveau);
doc.SaveFile("users.xml");  // enregistrement des modifications

Voici mon implémentation d'une classe de gestion d'utilisateurs. Cette classe implémente les opérations de chargement, de modification, de suppression et d'ajout d'utilisateurs.

• user_mgr.cpp ;
• user.h ;
• user_mgr.h.

Vous l'aurez compris, TinyXML se veut très facile à prendre en main. Il permet de gérer des données XML très simplement. Par contre, il ne permet pas de faire de la validation de fichiers par rapport à une grammaire. À chaque utilisation son outil, celui-là étant très léger, il trouvera facilement sa place dans des applications aussi diverses que variées.

Et voici quelques liens connexes :

• De la documentation sur le XML
• La doc officielle de TinyXML
• Le site officiel de TinyXML

Je tiens à remercier toute l'équipe de la section C/C++ en particulier Loulou24, Aurelien.Regat-Barrel et Ti-R pour la relecture de cet article.