source: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_treatment.hpp @ 124

#ifndef __ABSTRACT_DATA_TREATMENT__
#define __ABSTRACT_DATA_TREATMENT__

namespace XMLIOSERVER
{
   class AbstractDataTreatment
   {
      public :

         const Context* getCurrentContext(void) const
         { return (currentContext); }

         const std::vector<CFile*>& getEnabledFiles(void) const
         { return (enabledFiles); }

         void getEnabledFilesId(std::vector<std::string>& _vect) const
         {
            for (unsigned int i = 0; i < enabledFiles.size(); i++)
               _vect.push_back(enabledFiles[i]->getId());
         }

         void printEnabledFilesId(std::ostream& out = std::clog) const
         {
            out << "Liste des fichiers à sortir dans le contexte analysé nommé \""
                << currentContext->getId() << "\"" << std::endl;

            std::vector<std::string> __vect;
            this->getEnabledFilesId(__vect);

            for (unsigned int i = 0; i < __vect.size(); i++)
               out << __vect[i] << "|";
            out << "fin" << std::endl;
         }

         template <class T>
            bool writeData(const std::string& id, const T& arr)
         {
            const CField* const field_entry = CField::GetObject(id);
            const vector<CField*>& vectRef = field_entry->getVectRefObject();

            std::vector<CField*>::const_iterator it;
            for (it = vectRef.begin(); it != vectRef.end(); it++ )
            {
               if ((*it)->isStorable(currentContext->getCalendar()->getCurrentDate()))
               { // Stockage des données dans l'instance CField si nécessaire.
                  Array<double, 1> data_uni;
                  (*it)->getGrid()->storeField(arr, data_uni);
                  (*it)->storeData(data_uni, currentContext->getCalendar()->getCurrentDate());
               }
            }

            return (false);
         }
         virtual void createDataOutput(void) = 0;

         virtual ~AbstractDataTreatment()
         { /* Ne rien faire de plus */ }

      protected :

         AbstractDataTreatment(Context* const _ctxt, const AbstractCalendar& cal) : enabledFiles(), currentContext(_ctxt)
         {
            //std::cout << "(Message temporaire) Résolution des héritages ..." << std::endl;
            // Résolution des héritages pour le context actuel (Context::ResolveInheritance() résoud les héritages pour tous les contextes).
            solveAllInheritance();

            // Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
            //std::cout << "(Message temporaire) Initialisation du vecteur enabledFiles ..." << std::endl;
            findEnabledFiles();

            // Recherche des champs à sortir (enable à true + niveau de sortie correct) pour chaque fichier précédemment listé.
            //std::cout << "(Message temporaire) Recherche des champs à sortir ..." << std::endl;
            findAllEnabledFields(cal.getInitDate());

            // Résolution des références de grilles pour chacun des champs.
            //std::cout << "(Message temporaire) Résolution des références de grilles ..." << std::endl;
            solveAllGridRef();

            //std::cout << "(Message temporaire) fin traitement sorties ..." << std::endl;
         }

         std::vector<CFile*> enabledFiles; // Liste des fichiers à créer dans un context donné.

      private :

         void findAllEnabledFields(const Date& iniDate)// <- ajouter attribut par défault ici.
         {
            for (unsigned int i = 0; i < enabledFiles.size(); i++)
               enabledFiles[i]->findEnabledFields(iniDate);
         }

         void solveAllGridRef(void)
         {
            for (unsigned int i = 0; i < enabledFiles.size(); i++)
               enabledFiles[i]->solveEFGridRef();
         }

         void solveAllInheritance(void) const
         {
            // Résolution des héritages descendants (cà d des héritages de groupes) pour chacun des contextes.
            currentContext->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();
         }

         void findEnabledFiles(void)
         {
            const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();

            for (unsigned int i = 0; i < allFiles.size(); i++)
               if (allFiles[i]->enabled.hasValue()) // Si l'attribut 'enabled' est défini.
                  if ((bool)allFiles[i]->enabled) // Si l'attribut 'enabled' est fixé à vrai.
                     enabledFiles.push_back ( allFiles[i] );

            if (enabledFiles.size() == 0)
               WARNING("Aucun fichier ne va être sorti dans le contexte nommé \"" + currentContext->getId() + "\" !");
         }

         Context* const currentContext;

   }; //class AbstractDataTreatment

}// namespace XMLIOSERVER

#endif //__ABSTRACT_DATA_TREATMENT__