source: XMLIO_V2/dev/dev_rv/src/XMLIO/data_treatment.hpp @ 126

#ifndef __DATA_TREATMENT__
#define __DATA_TREATMENT__

namespace XMLIOSERVER
{
   class DataTreatment
   {
      public :

         DataTreatment(Context* const _ctxt       = Context::GetCurrentContext(),
                      const AbstractCalendar& cal = *Context::GetCurrentContext()->getCalendar())
            : enabledFiles(), currentContext(_ctxt)
         { this->doTreatment(cal); }

         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();
            const Date& curDate = currentContext->getCalendar()->getCurrentDate();

            std::vector<CField*>::const_iterator it;

            for (it = vectRef.begin(); it != vectRef.end(); it++ )
            {
               if ((*it)->isStorable(curDate))
               { // 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());
               }

               if (true)
               { // Ecriture des données si nécessaire.

               }
            }

            return (false);
         }

         template <class T>
            void createDataOutput(void)
         {
            for (unsigned int i = 0; i < enabledFiles.size(); i++)
            {
               // Initialisation des instances de sortie de données.
               enabledFiles[i]->initializeDataOutput(new T(enabledFiles[i]));
               // Ouverture des fichiers et création des entêtes.
               enabledFiles[i]->getDataOutput()->createFileAndHeader();
            }
         }

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

      protected :

         void doTreatment(const AbstractCalendar& cal)
         {
            // Résolution des héritages pour le context actuel (Context::ResolveInheritance() résoud les héritages pour tous les contextes).
            //std::cout << "(Message temporaire) Résolution des héritages ..." << std::endl;
            this->solveAllInheritance();

            //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
            //std::cout << "(Message temporaire) Initialisation du vecteur enabledFiles ..." << std::endl;
            this->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;
            this->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;
            this->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 DataTreatment

}// namespace XMLIOSERVER

#endif //__DATA_TREATMENT__