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

#ifndef __CONTEXT__
#define __CONTEXT__

#include "xmlio_std.hpp"
#include "xml_parser.hpp"

// Gestion des attributs
#include "attribut_registrar.hpp"
#include "attribut.hpp"
#include "declare_attribut.hpp"
#include "base_object.hpp"

// Pour les champs
#include "field.hpp"

/// HISTORIQUE ///
// <RV> 26/04/10- 27/04/10  : Nouvelle implémentation classes Simulation (racine) et Context séparées.
// <RV> 30/04/10            : Vérification de la classe avec XmlIOServer::XML::XMLClassTest comme enfant >> OK.

/**
 * \file  context.hpp
 * \brief Ce fichier contient le code source permettant d'analyser différents contexts de sortie.
 * \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 biliothÚque XmlIOServer
using XmlIOServer::XML::XMLElement;
using XmlIOServer::XML::TNodeType;
using XmlIOServer::XML::THashAttributes;
using XmlIOServer::XML::TListElements;

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

// Utilisation de la biliothÚque POCO
using Poco::HashMap;

namespace XmlIOServer
{
        class Simulation : public XMLElement
        {
                public:
                        Simulation()
                        { /*std::cout << "[simulation]" << std::endl;*/ } // sortie pour test uniquement.
                        
                        virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr);
                                
                        virtual XMLElement* getPReference(void) {return (NULL);}
                        
                        friend ostream& operator<< (ostream& out, const Simulation& c)
                        { out << "[simulation]";        return out;     }
                                                
                protected:
                
                private:                        
        
        }; // class Simulation
        
        // Pas nécessaire de créer cette classe mais utile pour vérification.
        class ContextAttribut : public virtual CBase_object
        {
                public :
                
                        /*DECLARE_ATTR(id, string) ; */
                        // Déclaration des autres attributs de la classe Context ici.

                        ContextAttribut()
                        { /*RegisterAttribut(id);*/ }
          
        }; // class ContextAttribut
        
        class Context : public XMLElement, public ContextAttribut
        {
                public:
                
                        typedef HashMap<string, Context*> THashContext;
                        
                        Context()
                                : field_definition(NULL, true), file_definition(this), grid_definition(this), axis_definition(this)
                        {std::cerr << "Context() > Ne devrait pas être appelé" << std::endl;}
                        
                        Context(TNodeType type, THashAttributes& attr)
                                : field_definition(this, true), file_definition(this), grid_definition(this), axis_definition(this)
                        {
                                // Ajout des attributs ...
                                AllContext[attr["id"]] = this;
                                
                                // TODO Vérifier l'existence de l'identifiant. 
                                this->setId(attr["id"]) ;
                                Context::SetCurrentContext(attr["id"]);
                        }
                        
                        static Simulation* GetRootElement() {return (Context::Root);}
                        static const THashContext& GetAllContext() {return (Context::AllContext);}
                        
                        static bool SetCurrentContext(const string& id)
                        {
                                if(Context::AllContext.end() == Context::AllContext.find(id))return (false);
                                CurrentContextID = id;
                                
                                return (true);
                        }
                        static Context* GetCurrentContext(void) { return(Context::AllContext[CurrentContextID]);}
                        static string& GetCurrentContextID(void){ return(Context::CurrentContextID); }
                        
                        /// POUR PARSING ///
                        virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr)
                        {                               
                                switch (type)
                                {
                                        case (TNodeType::FIELD_GROUP): // FIELD_GROUP
                                        // Autres actions à effectuer ici... //
                                                if (attr.end() != attr.find("id")) this->field_definition.setId(attr["id"]); // l'id est-il utile ici?
                                                this->field_definition.setAttributes(attr);
                                                std::cout << "    " << this->field_definition << std::endl;
                                                return (&field_definition);
                                                
                                        case (TNodeType::FILE_GROUP): // FILE_GROUP
                                        // Autres actions à effectuer ici... //
                                                return (&file_definition);
                                                
                                        case (TNodeType::AXIS_GROUP): // AXIS_GROUP
                                        // Autres actions à effectuer ici... //
                                                return (&axis_definition);      
                                                
                                        case (TNodeType::GRID_GROUP): // GRID_GROUP
                                        // Autres actions à effectuer ici... //
                                                return (&grid_definition);      
                                        default :
                                                std::cerr << "Balise inconnue sur context"<< std::endl;
                                                return (NULL);
                                }
                        }
                        
                        friend ostream& operator<< (ostream& out, const Context& c)
                        { out << "  [context id=\'" << c.id << "\']"; return out; }
                                
                        virtual XMLElement* getPReference(void) {return (Context::GetRootElement());}
                        
                        FieldGroup& getFieldDefinition(void) {return (this->field_definition);}
                        
                        const XmlIOServer::XML::XMLClassTest& getFileDefinition (void) {return (this->file_definition);}
                        const XmlIOServer::XML::XMLClassTest& getGridDefinition (void) {return (this->grid_definition);}
                        const XmlIOServer::XML::XMLClassTest& getAxisDefinition (void) {return (this->axis_definition);}
                        
                        ~Context()
                        {/* Ne rien faire de plus pour le moment */ }
                        
                protected:
                
                private:
                
                        FieldGroup field_definition;
                        
                        XmlIOServer::XML::XMLClassTest  file_definition, grid_definition, axis_definition;
                
                        static string CurrentContextID;
                        static Simulation* Root;
                        static THashContext AllContext;
                
        }; //class Context
        
        // Variables statiques
        Simulation* Context::Root = new Simulation();   
        Context::THashContext Context::AllContext;      
        string Context::CurrentContextID;
        
        // Définition de Simulation::addChild reportée ici car Class Context non définie précédemment.
        XMLElement* Simulation::addChild(TNodeType type, TListElements& path, THashAttributes& attr)
        { 
                if (type != 1) std::cerr << "Type reçu sur Simulation invalide" << std::endl;
                Context *ct = new Context(type, attr);
                std::cout << *ct << std::endl;
                return (ct);
        }
        
}// namespace XmlIOServer

#endif //__CONTEXT__