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

#ifndef FIELD_HPP
#define FIELD_HPP

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

#include "base_object.hpp"
#include "object_template.hpp"
#include "group_template.hpp"

#include "field_attribut.hpp"

// Utilisation de la biliothÚque XmlIOServer
using XmlIOServer::XML::XMLElement;
using XmlIOServer::XML::TNodeType;
using XmlIOServer::XML::THashAttributes;
using XmlIOServer::XML::TListElements;

using XmlIOServer::XML::XMLParser;

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


class FieldGroup : public group<CBase_object>, public XMLElement,public CFieldGroupAttribut
{
        public :
                        
                FieldGroup(XMLElement* pgr, bool fd = false) : group<CBase_object>(), CFieldGroupAttribut()     
                { this->pgroup = pgr; this->fdefinition = fd; }
                        
                void setAttributes(const THashAttributes& attr)
                {
                        for (THashAttributes::ConstIterator it = attr.begin(); it != attr.end(); it++)
                                if ((*it).first.compare(string("id"))) // Non prise en compte de l'identifiant lors de l'affectation des attributs.
                                        this->setSAttribut((*it).first, (*it).second);
                        
                        return;
                }
                
                bool isFieldDefinition(void) { return (this->fdefinition); }
                
                void parseIncludedFile(const string& path, const TListElements& tpath)
                {
                        std::cout << "^^^^^^^^^^^^^^^^^^^^^^^^^" << std::endl;
                        string elname;                  
                        if (fdefinition) elname.assign("field_definition");
                        else elname.assign("field_group");
                        
                        {// PARSING     DE FICHIER INCLU
                                XMLParser parser(path, elname); 
                                parser.setTreePath(tpath);
                                parser.parse(this);
                        }
                        std::cout << "^^^^^^^^^^^^^^^^^^^^^^^^^" << std::endl;
                }
                
                friend ostream& operator<< (ostream& out, const FieldGroup& c)
                { 
                        if (c.fdefinition) out << "[field_definition " ;
                        else out << "[field_group" ;
                        if(c.hasId) out << " id=\'" << c.id << "\'"; 
                        for (unordered_map<string,CBaseAttribut *>::const_iterator it = c.attrMap.begin(); it != c.attrMap.end(); it++)
                                out << " " <<(*it).first << "=\'" << *((*it).second) << "\'"; 
                        out << "]";
                        return out;             
                }
                                
                FieldGroup* getFieldGroupChild(const string & Id) {return ((FieldGroup*)getGroup(Id)); }
                
                template <typename T>
                        T getFieldChild(const string & Id) {return ((T)getChild(Id)); }
                        
                /// IMPORTANT POUR PARSING ///
                virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr);
                virtual XMLElement* getPReference(void){ return (this->pgroup);}
                
                ~FieldGroup() {/* Ne rien faire de plus */}
                
        protected :
        
                // Vide pour le moment.
        
        private :
        
                XMLElement* pgroup;
                bool fdefinition;
                
}; // class FieldGroup

class Field : public XMLElement, public CObjectTemplate<Field>, public CFieldAttribut
{
        public:
                        
                Field(void) : CObjectTemplate<Field>(), CFieldAttribut() {} ;
                Field(const string & Id) : CObjectTemplate<Field>(Id), CFieldAttribut() {} ;
                
                void setAttributes(const THashAttributes& attr, const TListElements& path)
                {
                        // Mise en place des attributs hérités
                        for(unsigned int i = 1; i < path.size()-1; i++)
                                for (THashAttributes::ConstIterator it = path[i].list.begin(); it != path[i].list.end(); it++)
                                        if ((*it).first.compare(string("id")) 
                                        and (*it).first.compare(string("name"))
                                        and (*it).first.compare(string("description"))
                                        and (*it).first.compare(string("src")))
                                                this->setSAttribut((*it).first, (*it).second);
                
                        // Mise en place des attributs locaux
                        for (THashAttributes::ConstIterator it = attr.begin(); it != attr.end(); it++)
                                 if ((*it).first.compare(string("id")))// Non prise en compte de l'identifiant lors de l'affectation des attributs.
                                        this->setSAttribut((*it).first, (*it).second);
                        
                        return;
                }               
                
                // IMPORTANT : constructeur pour parsing
                Field(FieldGroup* pgr) : CObjectTemplate<Field>(), CFieldAttribut(){ this->pgroup = pgr; }              
                Field(FieldGroup* pgr, const string & Id) : CObjectTemplate<Field>(Id), CFieldAttribut() { this->pgroup = pgr; }        
                
                // getName est-elle vraiment nécessaire?
                static const char * getName(void) { return ("field") ; }
    
                /// IMPORTANT POUR PARSING ///
                virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr) { return (NULL); } // Aucun retour car élément en fin d'arbre.    
                virtual XMLElement* getPReference(void){ return (this->pgroup);}
                
                friend ostream& operator<< (ostream& out, const Field& c)
                { 
                        out << "[field" ;       
                        if(c.hasId) out << " id=\'" << c.id << "\'";    
                        for (unordered_map<string,CBaseAttribut *>::const_iterator it = c.attrMap.begin(); it != c.attrMap.end(); it++)
                                out << " " <<(*it).first << "=\'" << *((*it).second) << "\'"; 
                        out << "]";
                        return out;             
                }
                
                ~Field()
                {/* Ne rien faire de plus */}

        protected :
        
                // Vide pour le moment.
                
        private :
        
                FieldGroup* pgroup;
                
}; // class Field

XMLElement* FieldGroup::addChild(TNodeType type, TListElements& path, THashAttributes& attr)
{
        FieldGroup* childgroup = NULL;
        Field* childfield = NULL;
                
        switch (type)
        {
                case (TNodeType::FIELD_GROUP): // FIELD_GROUP
                {
                        // Autres actions à effectuer ici... //
                        childgroup = new FieldGroup(this);
                        this->groupList->push_back(childgroup) ;
                        
                        
                        if (attr.end() != attr.find("id"))
                        {
                                pair<string,FieldGroup*> value(attr["id"], childgroup) ;
                                this->groupListId->insert(value);
                                childgroup->setId(attr["id"]);
                        }
                        childgroup->setAttributes(attr);
                        
                        for(int i = 0; i<path.size(); i++) std::cout << "  ";
                        std::cout << *childgroup << std::endl;
                        
                        // Gestion de l'inclusion de fichier.
                        if (attr.end() != attr.find("src")) 
                                childgroup->parseIncludedFile(attr["src"], path);
                        
                        return (childgroup);
                }
                        
                case (TNodeType::FIELD): // FIELD
                {
                        // Autres actions à effectuer ici... //
                        childfield = new Field(this);
                        this->childList->push_back(childfield) ;                                                        
                        
                        if (attr.end() != attr.find("id"))
                        {
                                pair<string,Field*> value(attr["id"], childfield) ;
                                this->childListId->insert(value);
                                childfield->setId(attr["id"]);
                        }
                        childfield->setAttributes(attr, path);
                        
                        for(int i = 0; i<path.size(); i++) std::cout << "  ";
                        std::cout << *childfield << std::endl;
                                
                        return (childfield);
                }                                               
                
                default :
                
                        std::cerr << "Balise inconnue sur FieldGroup"<< std::endl;
                        return (NULL);
        }
};// Méthode FieldGroup::addChild

#endif