source: XMLIO_V2/dev/dev_rv/old/xml_parser.hpp @ 90

#ifndef __XML_PARSER__
#define __XML_PARSER__

#include "xmlio_std.hpp"

/// HISTORIQUE ///
// <RV> 20/04/10 - 23/04/10 : Nouvelle implémentation parsing, création de la classe principale XmlIOServer::XML::XMLParser.
// <RV> 23/04/10            : Création de la classe abstraite XmlIOServer::XML::XMLElement + ajout de quelques commentaires.
// <RV> 26/04/10            : Ajout de la gestion simplifiée des héritages descendants + gestion des flux de sortie.
// <RV> 29/04/10            : Ajout de la gestion simplifiée des attributs par défaut.
// <RV> 30/04/10            : Création et Vérification de la classe de test XML XmlIOServer::XML::XMLClassTest.
// <RV> 03/05/10            : Nouvelle implémentation classe de test + ajout de tous les commentaires.
// <RV> 04/05/10            : Suppression documentation excessive + correction de 2 problÚmes de parsing sur situations particuliÚres non gérées.

/**
 * \file  XMLParser.hpp
 * \brief Ce fichier contient le code source permettant de parser un fichier de configuration xml pour le serveur d'E/S.
 * \author Ozdoba Hervé (contact: herve.ozdoba@glsce.ipsl.fr)
 * \author Meurdesoif Yann (contact Yann.Meurdesoif@cea.fr)
 * \version 0.1.0
 * \date Avril - Mai  2010
 */

// Utilisation de la STL
using std::string;

using std::pair;
using std::vector;
using std::deque;

using std::ifstream;
using std::ostream;

// Utilisation de la biliothÚque POCO
using Poco::XML::DOMParser;
using Poco::XML::InputSource;

using Poco::XML::Document;
using Poco::XML::Node;
using Poco::XML::Element;

using Poco::XML::NamedNodeMap;

//using Poco::XML::AutoPtr;

using Poco::Exception;
using Poco::HashMap;

/**
 * \namespace XmlIOServer
 * \brief Cet espace de nommage regroupe l'intégralité des classes du serveur des E/S.
 * \see XmlIOServer::XML
 *
 * Espace de nommage général qui regroupe toutes les classes dont dépend le serveur de gestion des entrées/sorties
 * parallÚles avec configuration par fichier de données xml.
 */
namespace XmlIOServer
{
        /**
         * \namespace XmlIOServer::XML
         * \brief Cet espace de nommage contient les classes permettant de parser le fichier de configuration XML.
         */
        namespace XML
        {
                /**
                 * \typedef pair<string, string> TAttribute
                 * \brief Définition d'un type pair associant un nom d'attribut à sa valeur.
                 * \see TListAttributes
                 *
                 * Ce type permet de récupérer une pair contenant :
                 * \li Le nom de l'attribut;
                 * \li La valeur associée à l'attribut sous forme de chaîne de caractÚres.
                 */
                typedef pair<string, string> TAttribute;

                /**
                 * \typedef HashMap<string, string> THashAttributes
                 * \brief Définition d'une HashMap de TAttribute.
                 * \see TAttribute
                 */
                typedef HashMap<string, string> THashAttributes;
                
                /**
                 * \enum TNodeType
                 * \brief Définition d'un type de noeud xml.
                 */
                typedef enum 
                {
                        UNKNOWN = 0, CONTEXT = 1,
                        FIELD_GROUP = 2, FILE_GROUP = 3, AXIS_GROUP = 4, GRID_GROUP = 5,
                        FIELD = 6, FILE = 7, AXIS = 8, GRID = 9
                        
                } TNodeType;
                
                /**
                 * \struct XmlIOServer::XML::_element
                 * \brief  Association d'un type de noeud avec un HashMap des attributs qui lui sont associés.
                 */
                
                /**
                 * \typedef struct XmlIOServer::XML::_element TElement
                 * \brief Redéfinition du type _element pour simplification d'écriture.
                 * \see _element
                 */
                typedef struct _element
                {
                        /**
                         * \fn _element(TNodeType t, THashAttributes& l)
                         * \brief Simple constructeur du structure.
                         * \param t Un type d'élément.
                         * \param l Une HashMap d'attributs associé  à l'élément.
                         */
                        _element(TNodeType t, THashAttributes& l) : type(t),list(l)
                         { /* Ne rien faire de plus */};
                        
                        /**
                         * \var TNodeType type
                         * \brief Type d'élément.
                         */
                        TNodeType type; 
                        
                        /**
                         * \var THashAttributes list
                         * \brief HashMap d'attributs.
                         */                     
                        THashAttributes list; //< HashMap d'attributs.
                        
                } TElement;
                
        
                /**
                 * \typedef deque<TElement> TListElements
                 * \brief Liste de TElement utilisée comme pile pour la gestion (optionnelle) 
                 *      de l'héritage descendant dans la classe de parsing xml.
                 * \see XmlIOServer::XML::XMLParser::path
                 */
                typedef deque<TElement> TListElements;

                /**
                 * \typedef Document* PDocument
                 * \brief Redéfinition du pointeur sur document xml pour simplification d'écriture.
                 */
                typedef Document*       PDocument;
                
                /**
                 * \typedef Node* PNode
                 * \brief Redéfinition du pointeur sur noeud xml pour simplification d'écriture.
                 * \see XmlIOServer::XML::cNode
                 */
                typedef Node*           PNode;
                
                /**
                 * \class XMLElement
                 * \brief Classe abstraite pour parsing xml.
                 * \see XmlIOServer::XML::XMLParser
                 * 
                 * Les classes susceptibles d'être instanciées par parsing Xml doivent hériter des fonctions de celle-ci pour être
                 * traoter par la classe XMLParser.
                 */
                class XMLElement
                {
                        public :
                        
                                // TODO ? Enlever le param. name serait une bonne chose ?
                                /**
                                 * \fn XMLElement* addChild(TNodeType type, string name, THashAttributes& attr)
                                 * \brief Fonction appelée par XMLParser signifiant l'ajout d'un fils à l'élément actuel.
                                 * \param type le type du noeud à ajouter.
                                 * \param name le nom du noeud à ajouter (lié au paramêtre <i>type</i>)
                                 * \param attr une HashMap des attributs associés à l'élément à ajouter.
                                 * \return Un pointeur sur l'élément fils nouvellement créé. 
                                 */
                                virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr) = 0;
                                
                                                
                                /**
                                 * \fn XMLElement* getPReference(void)
                                 * \brief Renvoie la référence au noeud parent e l'élément actuel.
                                 * \return la référence au noeud parent.
                                 * 
                                 */
                                virtual XMLElement* getPReference(void) = 0;
                                                        
                }; // class XMLElement
                
                /**
                 * \class XMLClassTest
                 * \brief Une classe de test pour le parsing xml.
                 *  
                 * Une simple classe de test qui écrit les arguments reçus lors du parsing vers la console.
                 */             
                class XMLClassTest : public XMLElement
                {
                        public:
                        
                                /**
                                 * \fn XMLClassTest()
                                 * \brief Simple constructeur d'initialisation d'un élément racine.
                                 */
                                XMLClassTest(XMLElement* ref = NULL)
                                {
                                        this->pref = ref;
                                        //std::cout << "[simulation]" << std::endl;
                                }
                        
                                /**
                                 * \fn XMLClassTest(XMLClassTest* ref, TNodeType type, string& name, THashAttributes& attr)
                                 * \brief Constructeur pour tout autre élément que celui de la racine.
                                 * \param ref Référence à l'élement parent (théorique, celui qui appelle le constructeur via la méthode addChild).
                                 * \param type Le type du noeud à instancier.
                                 * \param name Le nom du noeud à instancier.
                                 * \param attr Une HashMap des attributs liés au noeud à instancier.
                                 */
                                XMLClassTest(XMLClassTest* ref, TNodeType type, THashAttributes& attr)
                                {
                                        this->pref = ref;
                                        //for(int i = 0; i<INC; i++) std::cout << "  ";
                                        /*std::cout << "[" << type;
                                        
                                        for (THashAttributes::Iterator it = attr.begin(); it != attr.end(); it++)
                                                std::cout << " "<< (*it).first<< "=\"" << (*it).second << "\"";
                                                
                                        std::cout << "]" << std::endl;*/
                                }
                                
                                friend ostream& operator<< (ostream& out, const XMLClassTest& c)
                                { out << "[Non implémentée]" << std::endl; return out; }
                                
                                virtual XMLClassTest* addChild(TNodeType type, TListElements& path, THashAttributes& attr) 
                                { INC++; return (new XMLClassTest(this, type, attr)); }
                                
                                virtual XMLElement* getPReference(void) { INC--; return (this->pref); }
                                
                                /**
                                 * \fn ~XMLClassTest() 
                                 * \brief Simple destructeur.
                                 */
                                ~XMLClassTest() { /* Ne rien faire de plus */ }
                                
                        protected:
                        
                        private:
                        
                                /**
                                 * \var XMLClassTest* pref
                                 * \brief Référence au parent de l'élÚment actuel (NULL si on se trouve à la racine).
                                 */
                                XMLElement* pref; // TODO Vérifier la gestion de la mémoire.
                                
                                /**
                                 * \var int INC
                                 * \brief Entier permettant de connaître le niveau d'incrémentation pour l'écriture sur la sortie standard.
                                 */
                                static int INC;
                                
                }; // class XMLClassTest
                
                int XMLClassTest::INC = 0;

                /**
                 * \class XMLParser
                 * \brief Classe qui initie le parsing d'un fichier de configuration Xml.
                 *
                 * Cette classe permet de parser un document XML afin de configurer le serveur des E/S.\n
                 * Cette méthode de récupération des paramÚtres est statique puisque le traitement est effectué une fois au
                 * démarrage du serveur.\n Elle est complémentaire d'une seconde méthode, dynamique cette fois, consistant à paramétrer
                 * l'application par remoting client-serveur à travers MPI.
                 */
                class XMLParser
                {
                        public :

                                XMLParser(const string& filename, const string& rootName = string("simulation"))
                                { 
                                        XMLParser();
                                        ifstream istr( filename.data() , ifstream::in );
                                        if ((istr.good()))
                                        { // S'il est possible de lire le flux en entrée ...
                                                InputSource src(istr);
                                                DOMParser parser;

                                                // On parse la source XML et on vérifie que le premier noeud (racine) est du type "Element"
                                                // ... et à pour valeur la chaîne rootName.
                                                PDocument pDoc = parser.parse(&src);
                                                if (!(pDoc->documentElement()->nodeName().compare(rootName)))
                                                {
                                                        this->cNode = pDoc->documentElement();
                                                        this->goToChildElement();
                                                }
                                                else
                                                        std::cout       << "L'élément racine doit avoir pour valeur <"<< rootName <<"> (\""
                                                                                <<  (pDoc->documentElement()->nodeName()) <<"\" lue)"<< std::endl;
        
                                        }
                                        else
                                                std::cout << "Impossible de lire le flux du fichier en entrée !" << std::endl;
                                }

                                
                                void parse(XMLElement* const root, ostream& log = std::cout)
                                {
                                        XMLElement* current = root;
                                        THashAttributes attr;
                                        bool start = true;
                                        
                                        do{
                                                if(!start)path.pop_back();
                                                while((start) ? start : this->goToNextElement()) // PARCOURS SUR ELEMENT SUIVANT
                                                {
                                                        // APPEL ADD PARENT
                                                        if(!start)path.pop_back();
                                                        
                                                        this->getAttributes(attr);
                                                        path.push_back(TElement(this->getElementType(), attr));
                                                        current = current->addChild(this->getElementType(),this->getTreePath(), attr);
                                                        attr.clear();
                                                        
                                                        while (this->goToChildElement()) // PARCOURS SUR ELEMENT ENFANT
                                                        {
                                                                // APPEL ADD LOCAL
                                                                this->getAttributes(attr); // ou getGlobalAttributes pour gestion de l'héritage descendant.
                                                                path.push_back(TElement(this->getElementType(), attr));
                                                                current = current->addChild(this->getElementType(),this->getTreePath(), attr);
                                                                attr.clear();
                                                        }

                                                        current = current->getPReference();

                                                        if (start) start = false;                       
                                                }
                                                
                                                if(current == root ) break; 
                                                else current = current->getPReference();
                                                                        
                                        } while(this->goToParentElement()); // PARCOURS SUR ELEMENT PARENT
                                        
                                        return;
                                }
                
                                ~XMLParser()
                                { /* Ne rien faire pour le moment*/ }
                                
                                static void ClassTest(const char* path)
                                {
                                        try
                                        {                                       
                                                // Instanciation du parseur.
                                                XMLParser parser(path);                                                                                 
                                                // Instanciation de l'objet racine.
                                                XMLClassTest root ; 
                                        
                                                // Début du parsing XML ...
                                                parser.parse(&root);
                                        }
                                        catch (Exception& exc)
                                        {
                                                // TODO : Remplacer sorties vers cerr et cout par exception
                                                std::cerr << (exc.displayText()) << std::endl;
                                        }
                                                                                
                                        return;
                                }
                                
                                TListElements& getTreePath() { return (this->path); }
                                void setTreePath(const TListElements& p) { this->path = p; }

                        protected :
                                
                                TNodeType getElementType(void) const 
                                {
                                        if(this->isElementName("context"))return (CONTEXT);
                                        
                                        // les groupes, quels qu'ils soient.
                                        if(this->isElementName("field_definition") or this->isElementName("field_group"))return (FIELD_GROUP);
                                        if(this->isElementName("file_definition")  or this->isElementName("file_group")) return (FILE_GROUP);
                                        if(this->isElementName("axis_definition")  or this->isElementName("axis_group")) return (AXIS_GROUP);
                                        if(this->isElementName("grid_definition")  or this->isElementName("grid_group")) return (GRID_GROUP);
                                        
                                        // les éléments finaux (hormis "file").
                                        if(this->isElementName("field"))return (FIELD);
                                        if(this->isElementName("file")) return (FILE);
                                        if(this->isElementName("axis")) return (AXIS);
                                        if(this->isElementName("grid")) return (GRID);
                                        
                                        return (UNKNOWN);
                                }
                                
                                //////////////////////// PARSING //////////////////////////////

                                // TODO voir pour récupérer une référence.
                                string getElementName(void) const {return (this->cNode->nodeName());}
                                
                                bool isElementName(const char* val) const {return !(this->getElementName().compare(string(val)));}
                                
                                bool goToNextElement(Node* nextElement = 0) 
                                {
                                        nextElement = (!nextElement)? this->cNode->nextSibling() : nextElement;
                                        
                                        // On parcourt la liste des "siblings" jusqu'à trouver un élément quelconque.
                                        for(; ; nextElement = nextElement->nextSibling())
                                                if (nextElement == NULL) break;
                                                else if (nextElement->nodeType() == 1)
                                                {// Si l'un des noeuds est un élément...
                                                        this->setCurrentNode(nextElement);
                                                        return (true);
                                                } 
                                        return (false);
                                }
                                
                                bool goToChildElement(void)
                                {
                                        // On parcourt la liste des enfants jusqu'à trouver un élément quelconque.
                                        if (this->cNode->firstChild())
                                                if (this->goToNextElement(this->cNode->firstChild()))
                                                        return (true);
                                                        
                                        return (false);
                                }
                                
                                bool goToParentElement(void)
                                { 
                                        // Pas de retour au parent si on est à la racine.
                                        if (!(this->getElementName().compare(string("simulation")))) return (false);
                                        this->setCurrentNode(this->cNode->parentNode());
                                        return (true);
                                }
                                
                                bool getAttributes(THashAttributes& attributes)
                                {
                                        if(!this->cNode->hasAttributes()) return (false);
                                        NamedNodeMap* map = this->cNode->attributes();
                                        
                                        for(unsigned int i = 0; i< map->length(); i++)
                                                attributes[map->item(i)->nodeName()] = map->item(i)->nodeValue();

                                        return (true);
                                }
                                
                        private :
                        
                                XMLParser() : path() //pDoc(), cNode() << Ancien
                                { /* Ne rien faire de plus */ }
                        
                                bool setCurrentNode(PNode node){ if (!node) return false; this->cNode = node; return (true);}                           
                                PNode getCurrentNode(void){return (this->cNode);}

                                /** 
                                 * \var AElement cNode
                                 * \brief Pointeur sur l'objet représentant l'élément courant.
                                 */
                                PNode  cNode;
                                
                                TListElements path;
                                                
                };// class XMLParser
                
        };// namespace XML
        
};// namespace XmlIOServer

#endif //__XML_PARSER__