source: XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp @ 128

#include "xmlio.hpp"

using namespace XMLIOSERVER;
using namespace XMLIOSERVER::XML;

using namespace std;

extern "C" void main_c_(void) ;

// Cette fonction remplit un tableau à N dimensions de valeurs de type T (T = double ou float) de la maniÚre suivante :
// 0.0 1.0 2.0 3.0, puis 0.1 1.1 2.1 3.1 ... au second appel de la fonction, etc.
template <class T>
   static void updateDataTest(T begin, T end)
{
   static int called = 0; int i = 0;
   for (T it = begin; it != end; it++, i++)
      (*it) = i + called * 0.01;
   called++;
}

void main_c_ (void)
{
   try
   {
      Array<double, 3> arr(100, 100, 20) ; // Initialisation des données (les arguments en fonction des dimensions).
      string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_simple_test.xml"); // Le fichier de définition.
      ifstream istr( file.c_str() , ifstream::in );

      // On commence la lecture du flux de donnée xml qui doit posséder pour racine un unique noeud nommé "simulation".
      XMLNode node = XMLNode::CreateNode(istr, Context::GetRootName());

      // On parse le fichier xml noeud par noeud (ie on construit dynamiquement notre arbre d'objets).
      XMLParser::Parse(node);

      // On se place dans le contexte 'context1'.
      Context::SetCurrentContext("context1", true) ;

      std::cout << " * ----------- Début du traitement ----------- * " << std::endl << std::endl;

      {
         // On crée une instance de traitement de données dans le format NetCDF4.
         DataTreatment dtreat;
         dtreat.createDataOutput<NetCDF4DataOutput>();

         // Récupération du calendrier assossié au context courant et initialisation des delais d'écriture.
         AbstractCalendar* calendar = dtreat.getCurrentContext()->getCalendar();
         calendar->setTimeStep(1 * Hour);

         // Affichage de la date initiale (pour vérification).
         std::cout << "Calendrier associé au contexte : " << *calendar << std::endl << std::endl;

         for(int tcourant = 0, tfinal = 9; tcourant <= tfinal; tcourant++)
         { /***************************** BOUCLE DE CALCUL *****************************/

            // Mise à jour de la date.
            calendar->update();

            // Affichage des informations temporelles sur l'itération actuelle.
            std::cout << "> Itération de calcul effectuée à la date t" << tcourant << " = " << calendar->getCurrentDate()
                      << " (soit aprÚs " << (Time)calendar->getCurrentDate() << " sec.)." << std::endl;

            // Mise à jour des données.
            updateDataTest<Array<double, 3>::iterator>(arr.begin(), arr.end());

            // Ecriture des données.
            dtreat.writeData<Array<double, 3> >("champ1", arr);
         }

         // Ecriture des avertissements obtenus jusqu'à présent.
         std::cout << std::endl; ILogger::Flush(std::cout);

         /*std::cout << " * ----------- Affichage de l'arborescence ----------- * " << std::endl << std::endl;

         // On écrit l'arborescence résultante du traitement sur la sortie de log.
         Context::ShowTree(std::clog);
         std::cout << std::endl;*/
      }

   }
   catch(const Exception &exc)
   {  // Pour tout type d'exceptions, on note les informations sur la sortie paramétrée.
      ERROR(exc.displayText());
      // On retourne le code d'erreur en fin d'application pour traitements éventuels.
      // return (exc.code());
   }

   // return (0);
}