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

#ifndef __CONTEXT__
#define __CONTEXT__


namespace XMLIOSERVER
{
   class DataTreatment;

   class Context : public ObjectTemplate<Context>
   {
      public:

         Context(void)
            : ObjectTemplate<Context>(),
              dtreatment(NULL), ccalendar(NULL),
              fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL), domainDef(NULL)
         { /* Ne rien faire de plus */ }

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

         bool createDefinitions(void)
         {
            if (hasChild()) return false;
            this->fieldDef  =
               (FieldDefinition*) FieldDefinition ::CreateObject(FieldDefinition ::GetDefName());
            this->fileDef   =
               (FileDefinition*)  FileDefinition  ::CreateObject(FileDefinition  ::GetDefName());
            this->axisDef   =
               (AxisDefinition*)  AxisDefinition  ::CreateObject(AxisDefinition  ::GetDefName());
            this->gridDef   =
               (GridDefinition*)  GridDefinition  ::CreateObject(GridDefinition  ::GetDefName());
            this->domainDef =
               (DomainDefinition*)DomainDefinition::CreateObject(DomainDefinition::GetDefName());
            return (true);
         }

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

         AbstractCalendar * getCalendar     (void) const { return (ccalendar ); }
         DataTreatment    * getDataTreatment(void) const { return (dtreatment); }

         AbstractCalendar * setCalendar(AbstractCalendar * const _cal) { return (ccalendar = _cal);}

         AbstractCalendar * setCalendar(const string& _calName, const string& _dateStr)
         {
            if(ccalendar  !=  NULL) delete ccalendar;

            if (_calName.compare("D360")      == 0)
               return (ccalendar = new D360Calendar(_dateStr));
            if (_calName.compare("AllLeap")   == 0)
               return (ccalendar = new AllLeapCalendar(_dateStr));
            if (_calName.compare("NoLeap")    == 0)
               return (ccalendar = new NoLeapCalendar(_dateStr));
            if (_calName.compare("Julian")    == 0)
               return (ccalendar = new JulianCalendar(_dateStr));
            if (_calName.compare("Gregorian") == 0)
               return (ccalendar = new GregorianCalendar(_dateStr));

            WARNING("L'identifiant "+_calName+" est inconnu, le calendrier grégorien sera choisi par défault pour le contexte "+getId());

            return (ccalendar = new GregorianCalendar(_dateStr));
         }

         template <class T>
            DataTreatment * setDataTreatment(void)
         { return (dtreatment = (ccalendar == NULL)? NULL : new T(this)); }

      public : /* virtual */

         virtual ~Context(void)
         {
            // Désallocation dynamique de mémoire pour chacun des groupes de définition si nécessaire.
            if( fieldDef != NULL) delete  fieldDef ; if(fileDef  != NULL) delete fileDef ;
            if(  axisDef != NULL) delete   axisDef ; if(gridDef  != NULL) delete gridDef ;
            if(domainDef != NULL) delete domainDef ;

            // Désallocation dynamique de mémoire pour le calendrier associé au contexte courant si nécessaire.
            if(ccalendar  !=  NULL) delete ccalendar;
            // INFO La mémoire dédiée à dtreatment est désallouée ailleurs.
         }

         virtual 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 contextes 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 pour la définition des champs.
                  { fieldDef  = CreateInstanceAndParse<FieldDefinition >
                                 (_node, FieldDefinition::GetDefName().c_str()); continue; }

                  if (name.compare(FileDefinition::GetDefName())  == 0)
                  // Parsing pour la définition des fichiers.
                  { fileDef   = CreateInstanceAndParse<FileDefinition  >
                                 (_node, FileDefinition  ::GetDefName().c_str()); continue; }

                  if (name.compare(AxisDefinition::GetDefName())  == 0)
                  // Parsing pour la définition des axes.
                  { axisDef   = CreateInstanceAndParse<AxisDefinition  >
                                 (_node, AxisDefinition  ::GetDefName().c_str()); continue; }

                  if (name.compare(GridDefinition::GetDefName())  == 0)
                  // Parsing pour la définition des grilles.
                  { gridDef   = CreateInstanceAndParse<GridDefinition  >
                                 (_node, GridDefinition  ::GetDefName().c_str()); continue; }

                  if (name.compare(DomainDefinition::GetDefName()) == 0)
                  // Parsing pour la définition des domaines.
                  { domainDef = CreateInstanceAndParse<DomainDefinition>
                                 (_node, DomainDefinition::GetDefName().c_str()); continue; }

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

               } while (_node.goToNextElement());

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

         virtual bool hasChild(void) const
         { return ((fieldDef != NULL) or (fileDef != NULL)  or (axisDef != NULL) or (gridDef != NULL) or (domainDef != NULL)); }

         virtual void printChild(ostream& out) const
         {
            if( fieldDef != NULL) out << *( FieldDefinition*)  fieldDef << std::endl;
            if(  fileDef != NULL) out << *(  FileDefinition*)   fileDef << std::endl;
            if(  axisDef != NULL) out << *(  AxisDefinition*)   axisDef << std::endl;
            if(  gridDef != NULL) out << *(  GridDefinition*)   gridDef << std::endl;
            if(domainDef != NULL) out << *(DomainDefinition*) domainDef << std::endl;
         }

         virtual void solveDescInheritance(const AttributRegistrar* const _parent = 0)
         {
            if (_parent != 0) return;
            // Résolution des héritages descendants pour chacun des groupes de définitions.
            if( fieldDef != NULL)  fieldDef->solveDescInheritance();
            if(  fileDef != NULL)   fileDef->solveDescInheritance();
            if(  axisDef != NULL)   axisDef->solveDescInheritance();
            if(  gridDef != NULL)   gridDef->solveDescInheritance();
            if(domainDef != NULL) domainDef->solveDescInheritance();
         }

      public : /* static */

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

         static void ShowTree(ostream& os = std::clog)
         {
            os << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
            os << NIndent << "<" << Context::GetRootName() << ">" << std::endl;

            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            Poco::HashMap<string, StrHashMap<Context> >::Iterator it;

            for (it = AllListContext.begin(); it != AllListContext.end(); it++)
               // On sort chacun des contextes successivement.
            {
               Context::SetCurrentContext((*it).first);
               os << NIndent << std::endl;
               os << *((*it).second)[(*it).first] << std::endl;
            }

            os << NIndent << std::endl;
            os << NIndent << "</" << Context::GetRootName() << ">" << std::endl  ;
         }

         static void FreeMemory(void)
         {
            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            Poco::HashMap<string, StrHashMap<Context> >::Iterator it;

            for (it = AllListContext.begin(); it != AllListContext.end(); it++)
            { Context::SetCurrentContext((*it).first); delete ((*it).second)[(*it).first]; }
         }

         // Ne plus utiliser, disponible dans les classe treatment.
         static void SolveInheritance(void)
         {
            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
            Poco::HashMap<string, StrHashMap<Context> >::Iterator it;

            for ( 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]->solveDescInheritance();

               // 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]->solveFieldRefInheritance();
            }
         }

         static bool HasContext(const string& id)
         { return (Context::GetAllListObject().find(id) != Context::GetAllListObject().end()); }

         static Context* GetContext(const string& id)
         { return (Context::GetAllListObject()[id][id]); }

         static const std::stack<string>& GetStackContextId(void)
         { return (Context::Stid); }

         static Context* GetCurrentContext(void)
         { return (Context::GetObject(Context::GetCurrentContextId())); }

         static Context* SwapContext(void)
         {
            if (Stid.size() == 0)
            {
               WARNING("SwapContext impossible car le pile des contextes est vides !");
               return (NULL);
            }
            string lastId = Stid.top (); Stid.pop ();
            return (Context::GetObject(lastId));
         }

         static void SetCurrentContext(const string& id, bool withSwap = false, bool withcheck = true)
         {
            if (withSwap) Stid.push (Context::GetCurrentContextId());

            if (!Context::HasContext(id) && withcheck)
               throw new XMLIOUndefinedValueException
                     ("Impossible de se placer dans le contexte "+id+" car celui-ci n'existe pas dans l'arborescence!");

            // 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);

            // Changement de context pour les domaines et groupes de domaines.
            DomainGroup::SetContext(id); CDomain::SetContext(id);
         }

      private:

         static std::stack<string> Stid;

         DataTreatment    * dtreatment;
         AbstractCalendar * ccalendar;

          FieldDefinition * fieldDef;
           FileDefinition * fileDef;
           AxisDefinition * axisDef;
           GridDefinition * gridDef;
         DomainDefinition * domainDef;

   }; //class Context

   std::stack<string> Context::Stid;

}// namespace XMLIOSERVER

#endif  // __CONTEXT__