source: XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp @ 108

#ifndef __CONTEXT__
#define __CONTEXT__


namespace XMLIOSERVER
{
   class Context : public ObjectTemplate<Context>
   {
      public:

         Context(void) : ObjectTemplate<Context>(), fieldDef(NULL), fileDef(NULL)//, axisDef(NULL), gridDef(NULL)
         {/* Ne rien faire de plus */}
         Context(const string& _id) : ObjectTemplate<Context>(_id), fieldDef(NULL), fileDef(NULL)//, axisDef(NULL), gridDef(NULL)
         {/* Ne rien faire de plus */}

         static void ShowTree(ostream& os = std::clog)
         {
            clog << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
            clog << NIndent << "<"<< Context::GetRootName() << ">" << std::endl;
            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
               // On sort chacun des contextes successivement.
            { Context::SetCurrentContext((*it).first); clog << *((*it).second)[(*it).first] << std::endl; }
            clog << NIndent << "</" << Context::GetRootName() << ">" << std::endl  ;
         }

         static void FreeMemory(void)
         {
            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
            { Context::SetCurrentContext((*it).first); delete ((*it).second)[(*it).first]; }
         }

         static void ResolveInheritance(void)
         {
            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
            {
               // Résolution des héritages descendants (cà d des héritages de groupes) pour chacun des contextes.
               Context::SetCurrentContext((*it).first);
               ((*it).second)[(*it).first]->resolveDescInheritance();

               // Résolution des héritages par référence au niveau des fichiers
               const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
               for (unsigned int i = 0; i < allFiles.size(); i++) allFiles[i]->resolveFieldRefInheritance();
            }
         }

         static void SetCurrentContext(const string& id)
         {
            // On modifie le context courrant pour tout les ObjectTemplate
            Context::SetContext(id);

            // Changement de context pour les champs et groupes de champs.
            FieldGroup::SetContext(id);
            CField::SetContext(id);

            // Changement de context pour les fichiers et groupes de fichiers.
            FileGroup::SetContext(id);
            CFile::SetContext(id);

            // Changement de context pour les grilles et groupes de grilles.
            //GridGroup::SetContext(id);
            //CGrid::SetContext(id);

            // Changement de context pour les axes et groupes d'axes.
            //AxisGroup::SetContext(id);
            //CAxis::SetContext(id);
         }

         void parse (XMLNode& _node)
         {
            THashAttributes attributes;

            /// PARSING POUR GESTION DES ENFANTS
            if (_node.getElementName().compare(Context::GetName()))
               WARNING("Le noeud est mal nommé mais sera traité comme un context !");

            if (!(_node.goToChildElement()))
               WARNING("Le context ne contient pas d'enfant !");
            else
            {
              do { // Parcours des contexts pour traitement.

                  string name = _node.getElementName();
                  attributes.clear();
                  _node.getAttributes(attributes);

                  if (attributes.end() != attributes.find("id"))
                  { WARNING("Le noeud de définition possÚde un identifiant, ce dernier ne sera pas pris en compte lors du traitement !"); }

                  if (name.compare(FieldDefinition::GetDefName()) == 0) // Parsing définition des champs.
                  { fieldDef = CreateInstanceAndParse<FieldDefinition>(attributes, _node, "field_definition"); continue; }
                  if (name.compare(FileDefinition::GetDefName()) == 0) // Parsing définition des fichiers.
                  { fileDef = CreateInstanceAndParse<FileDefinition>(attributes, _node, "file_definition"); continue; }

                  if (name.compare("axis_definition") == 0)
                  { // Parsing pour la définition des axes.
                     INFO("Le parsing des définitions d'axes n'est pas encore implémenté");
                     //axisDef = CreateInstance<AxisDefinition>(attributes, _node, "axis_definition");
                     continue;
                  }

                  if (name.compare("grid_definition") == 0)
                  { // Parsing pour la définition des grilles.
                     INFO("Le parsing des définitions de grilles n'est pas encore implémenté");
                     //gridDef = CreateInstance<GridDefinition>(attributes, _node, "grid_definition");
                     continue;
                  }

                  WARNING("La définition est invalide, seules les champs, grilles, axes et fichiers peuvent être définis !");

               } while (_node.goToNextElement());

               _node.goToParentElement(); // Retour au parent
            }

            return;
         }

         static string GetName(void) {return ("context"); }
         static string GetRootName(void) {return ("simulation"); }

         virtual bool hasChild(void) const
         { return ((fieldDef != NULL) or (fileDef != NULL) /* or (axisDef != NULL) or (gridDef != NULL) */); }
         virtual void printChild(ostream& out) const
         {
            if(fieldDef != NULL) out << *(FieldGroup*)fieldDef << std::endl;
            if(fileDef != NULL)  out << *(FileGroup*) fileDef  << std::endl;
            //if(axisDef != NULL) out << *(AxisDefinition*)axisDef << std::endl;
            //if(gridDef != NULL) out << *(GridDefinition*)gridDef << std::endl;
         }
         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
         {
            // Résolution des héritages descendants pour chacun des groupes de définitions.
            if(fieldDef != NULL) fieldDef->resolveDescInheritance();
            if(fileDef != NULL)  fileDef ->resolveDescInheritance();
            //if(axisDef != NULL)  axisDef ->resolveDescInheritance();
            //if(gridDef != NULL)  gridDef ->resolveDescInheritance();
         }

         FieldDefinition* getFieldDefinition(void) { return (this->fieldDef); }
         FileDefinition*  getFileDefinition(void)  { return (this->fileDef);  }
         //AxisDefinition* getAxisDefinition(void) { return (this->axisDef); }
         //GridDefinition*  getGridDefinition(void)  { return (this->gridDef); }

         ~Context()
         {
            if(fieldDef != NULL) delete fieldDef;
            if(fileDef != NULL)  delete fileDef;
            //if(axisDef != NULL)  delete axisDef;
            //if(gridDef != NULL)  delete gridDef;
         }


      private:

         FieldDefinition*  fieldDef;
         FileDefinition*   fileDef;
         /*AxisDefinition*   axisDef;
         GridDefinition*   gridDef;*/


   }; //class Context
}// namespace XMLIOSERVER

#endif  // __CONTEXT__