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

#include "c_interface.hpp"

/* ********************************************************** */
/*                      HANDLE INTERFACE                      */
/* ********************************************************** */

#define CASE_ELEM(elem_enum, elem_class)                    \
         case (E##elem_enum):                               \
            *_ret = (!C##elem_class::HasObject(__id)) ?     \
               0 : C##elem_class::GetObject(__id);          \
            return;                                         \
         case (G##elem_enum):                               \
            *_ret = (!elem_class##Group::HasObject(__id)) ? \
               0 : elem_class##Group::GetObject(__id);      \
            return;

void xios_handle_create (XPtr * const _ret, XDType _dtype,
                         const XString _id, XSize _id_len)
{
   MAKE_STRING(__id, _id, _id_len);
   switch(_dtype)
   {
      case (ECONTEXT):
         // Si le context n'existe pas, on retourne un handle vide/nul.
         *_ret = (!Context::HasContext(__id)) ? 0 : Context::GetContext(__id) ;
         return ;
      CASE_ELEM(AXIS   , Axis);
      CASE_ELEM(DOMAIN , Domain);
      CASE_ELEM(FIELD  , Field);
      CASE_ELEM(FILE   , File);
      CASE_ELEM(GRID   , Grid);
      default :
         *_ret = 0;
         return ;
   };
}

#undef CASE_ELEM

/* ********************************************************** */
/*                      XML INTERFACE                         */
/* ********************************************************** */

void xios_xml_parse_file(const XString _filename, XSize _filename_len)
{

      MAKE_STRING(__filename, _filename, _filename_len);
      std::ifstream __istr( __filename.c_str() , std::ifstream::in );

      // On commence la lecture du flux de donnée xml.
      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);
}

void xios_xml_parse_string(const XString _xmlcontent, XSize _xmlcontent_len)
{
   MAKE_STRING(__xmlcontent, _xmlcontent, _xmlcontent_len);
   std::istringstream __istr(__xmlcontent);

   // On commence la lecture du flux de donnée xml.
   XMLNode node = XMLNode::CreateNode(__istr, Context::GetRootName());
   // On parse le document xml noeud par noeud
   XMLParser::Parse(node);
}
/* ********************************************************** */
/*                      CONTEXT INTERFACE                     */
/* ********************************************************** */

void xios_context_set_current (XPtr _ctx, bool _wswap)
{
   Context* const __ctxt = (Context*) _ctx;
   Context::SetCurrentContext(__ctxt->getId(), _wswap) ;
}

void xios_context_create (XPtr * _ctx, const XString _ctx_id,
                          XSize _ctx_id_len, XCalendarType _calType,
                          XInt yr, XInt mth, XInt dd,
                          XInt hr, XInt min, XInt sec)
{
   MAKE_STRING(__ctx_id, _ctx_id, _ctx_id_len);
   // si le contexte existe déjà , on arrête le traitement.
   if (Context::HasContext(__ctx_id)) { _ctx = NULL; return ; }

   Context::SetCurrentContext(__ctx_id, false, false);
   Context * context = Context::CreateObject(__ctx_id);
   context->createDefinitions(); *_ctx = context;

   if (!Context::HasContext(__ctx_id)) // Au cas où ...
      std::cerr << "La création du contexte a échoué ???" << std::endl;

   switch(_calType)
   {
      case (D360) :
         context->setCalendar(new D360Calendar(yr, mth, dd, hr, min, sec));
         return;
      case (ALLLEAP) :
         context->setCalendar(new AllLeapCalendar(yr, mth, dd, hr, min, sec));
         return;
      case (NOLEAP) :
         context->setCalendar(new NoLeapCalendar(yr, mth, dd, hr, min, sec));
         return;
      case (JULIAN) :
         context->setCalendar(new JulianCalendar(yr, mth, dd, hr, min, sec));
         return;
      case (GREGORIAN) :
         context->setCalendar(new GregorianCalendar(yr, mth, dd, hr, min, sec));
         return;
      default:
         std::cerr << "[context_create] Type de calendrier invalide [0-5]" << std::endl;
         return;
   }
}

/* ********************************************************** */
/*                    XML TREE INTERFACE                      */
/* ********************************************************** */

#define CASE_ELEM0(elem_enum, elem_class, group_enum, group_class)              \
      case (group_enum) : {                                                     \
         group_class * _group = (group_class *) _parent;                        \
         switch(_child_type) {                                                  \
            case (group_enum) :                                                 \
               if ((_child_id_len != -1) &&                                     \
                   (group_class::HasObject(___child_id))) return;               \
               *_child = (_child_id_len != -1)                                  \
                       ? (group_class *)(&_group->createGroup(___child_id))     \
                       : (group_class *)(&_group->createGroup());               \
               break;                                                           \
            case (elem_enum) :                                                  \
               if ((_child_id_len != -1) &&                                     \
                   (elem_class::HasObject(___child_id))) return;                \
               *_child = (_child_id_len != -1)                                  \
                       ? (elem_class *)(&_group->createChild(___child_id))      \
                       : (elem_class *)(&_group->createChild());                \
               break;                                                           \
            default :                                                           \
               std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; \
         }; return; }

void xios_xml_tree_add (const XPtr _parent, XDType _parent_type, XPtr * _child,
                        XDType _child_type, const XString _child_id, XSize _child_id_len)
{
   string ___child_id;
   if (_child_id_len != -1)
   {
      MAKE_STRING(__child_id, _child_id, _child_id_len);
      ___child_id = __child_id;
   }

   switch (_parent_type)
   {
      case (EFILE) :
      {
         CFile * _file = (CFile *) _parent;
         FieldGroup * _field_group = _file->createVirtualFieldGroup(_file->getId());
         xios_xml_tree_add (_field_group, GFIELD,
                            _child, _child_type, _child_id, _child_id_len);
         return;
      }
      CASE_ELEM0(EAXIS, CAxis, GAXIS, AxisGroup);
      CASE_ELEM0(EGRID, CGrid, GGRID, GridGroup);
      CASE_ELEM0(EDOMAIN, CDomain, GDOMAIN, DomainGroup);
      CASE_ELEM0(EFIELD, CField, GFIELD, FieldGroup);
      CASE_ELEM0(EFILE, CFile, GFILE, FileGroup);
      default :
         std::cerr << "[xml_tree_add] Type parent invalide" << std::endl;
         return;
   }
}

#undef CASE_ELEM0

void xios_xml_tree_show(const XString _filename, XSize _filename_len)
{
   string ___filename;
   if (_filename_len != -1)
   {
      MAKE_STRING(__filename, _filename, _filename_len);
      ___filename = __filename;
   }
   if (_filename_len == -1)
      // On écrit l'arborescence résultante du traitement sur la sortie de log.
      Context::ShowTree(std::clog);
   else
   {
      std::ofstream __outfile (___filename.c_str());
      // On écrit l'arborescence résultante du traitement dans le fichier.
      Context::ShowTree(__outfile);
      __outfile.close();
   }
}

#undef XML_SET
#undef XML_SET_STRING

#define XML_SET(ttype, type, type_var, var, long_var)                 \
   void xios_xml_set_##type##_##var                                   \
                  (XPtr const _##type, XDType _dtype, type_var var){  \
      if (_dtype >= 10 && _dtype <= 14) {                             \
         ttype##Group * __##type = (ttype##Group *) _##type;          \
         __##type->set_##long_var(var);                               \
      } else {                                                        \
         C##ttype * __##type = (C##ttype *) _##type;                  \
         __##type->set_##long_var(var);                               \
   }}


#define XML_SET_STRING(ttype, type, var, long_var)              \
   void xios_xml_set_##type##_##var(XPtr const _##type,         \
      XDType _dtype, const XString _##var, XSize _##var##_len) {\
      MAKE_STRING(___##var, _##var, _##var##_len);              \
      if (_dtype >= 10 && _dtype <= 14) {                       \
         ttype##Group * __##type = (ttype##Group *) _##type;    \
         __##type->set_##long_var(___##var);                    \
      } else {                                                  \
         C##ttype * __##type = (C##ttype *) _##type;            \
         __##type->set_##long_var(___##var);                    \
   }}

// Attributs de field ou field_group //
XML_SET_STRING(Field, field, name, name)
XML_SET_STRING(Field, field, sname, standard_name)
XML_SET_STRING(Field, field, lname, long_name)
XML_SET_STRING(Field, field, unit, unit)
XML_SET_STRING(Field, field, operation, operation)

void xios_xml_set_field_freq_op(XPtr const _field, XDType _dtype,
                                double year, double month, double day,
                                double hour, double minute, double second)
{
   const Duration _dur   = {year, month, day, hour, minute, second};
   if (_dtype >= 10 && _dtype <= 14)
   {
      FieldGroup * __field = (FieldGroup *) _field;
      __field->set_freq_op(_dur);
   } else {
      CField * __field = (CField *) _field;
      __field->set_freq_op(_dur);
   }
}

XML_SET(Field, field, int, level, level)
XML_SET(Field, field, int, prec, prec)
XML_SET(Field, field, bool, enabled, enabled)

XML_SET_STRING(Field, field, dref, domain_ref)
XML_SET_STRING(Field, field, aref, axis_ref)
XML_SET_STRING(Field, field, gref, grid_ref)
XML_SET_STRING(Field, field, zref, zoom_ref)
XML_SET_STRING(Field, field, fref, field_ref)

// Attributs de file ou file_group
XML_SET_STRING(File, file, name, name)
XML_SET_STRING(File, file, description, description)

void xios_xml_set_file_output_freq(XPtr const _file, XDType _dtype,
                                   double year, double month, double day,
                                   double hour, double minute, double second)
{
   const Duration _dur   = {year, month, day, hour, minute, second};
   if (_dtype >= 10 && _dtype <= 14)
   {
      FileGroup * __file = (FileGroup *) _file;
      __file->set_output_freq(_dur);
   } else {
      CFile * __file= (CFile *) _file;
      __file->set_output_freq(_dur);
   }
}

XML_SET(File, file, int, olevel, output_level)
XML_SET(File, file, bool, enabled, enabled)

// Attributs de grid ou grid_group
XML_SET_STRING(Grid, grid, name, name)
XML_SET_STRING(Grid, grid, description, description)
XML_SET_STRING(Grid, grid, dref, domain_ref)
XML_SET_STRING(Grid, grid, aref, axis_ref)

// Attribut de axis ou axis group
XML_SET_STRING(Axis, axis, name, name)
XML_SET_STRING(Axis, axis, sname, standard_name)
XML_SET_STRING(Axis, axis, lname, long_name)

XML_SET_STRING(Axis, axis, unit, unit)

void xios_xml_set_axis_value(XPtr const _axis, XDType _dtype,
                             double value[], XSize value_size)
{
   Array<double, 1> __arr(value, shape(value_size), neverDeleteData, FortranArray<1>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      AxisGroup * __axis = (AxisGroup *) _axis;
      __axis->set_size(value_size);
      __axis->zvalue.getValue()->resize(value_size);
      __axis->set_zvalue(__arr);
   } else {
      CAxis * __axis = (CAxis *) _axis;
      __axis->set_size(value_size);
      __axis->zvalue.getValue()->resize(value_size);
      __axis->set_zvalue(__arr);
   }
}

// Attribut de domain ou domain_group
XML_SET_STRING(Domain, domain, name, name)
XML_SET_STRING(Domain, domain, sname, standard_name)
XML_SET_STRING(Domain, domain, lname, long_name)

XML_SET(Domain, domain, int, niglo, ni_glo)
XML_SET(Domain, domain, int, njglo, nj_glo)

XML_SET(Domain, domain, int, ibegin, ibegin)
XML_SET(Domain, domain, int, iend, iend)
XML_SET(Domain, domain, int, ni, ni)

XML_SET(Domain, domain, int, jbegin, jbegin)
XML_SET(Domain, domain, int, jend, jend)
XML_SET(Domain, domain, int, nj, nj)

void xios_xml_set_domain_mask(XPtr const _domain, XDType _dtype, bool * _mask ,
                              XSize _maskXsize, XSize _maskYsize)
{
   Array<bool, 2> __arr(_mask, shape(_maskXsize, _maskYsize), neverDeleteData, FortranArray<2>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      DomainGroup * __domain = (DomainGroup *) _domain;
      __domain->mask.getValue()->resize(shape(_maskXsize, _maskYsize));
      __domain->set_mask(__arr);
   } else {
      CDomain * __domain = (CDomain *) _domain;
      __domain->mask.getValue()->resize(shape(_maskXsize, _maskYsize));
      __domain->set_mask(__arr);
   }

}

XML_SET(Domain, domain, int, ddim, data_dim)
XML_SET(Domain, domain, int, dni, data_ni)
XML_SET(Domain, domain, int, dnj, data_nj)
XML_SET(Domain, domain, int, dibegin, data_ibegin)
XML_SET(Domain, domain, int, djbegin, data_jbegin)

XML_SET(Domain, domain, int, dnindex, data_n_index)

void xios_xml_set_domain_diindex(XPtr const _domain, XDType _dtype,
                                 int _diindex[], XSize _diindex_size)
{
   Array<int, 1> __arr(_diindex, shape(_diindex_size), neverDeleteData, FortranArray<1>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      DomainGroup * __domain = (DomainGroup *) _domain;
      __domain->data_i_index.getValue()->resize(_diindex_size);
      __domain->set_data_i_index(__arr);
   } else {
      CDomain * __domain = (CDomain *) _domain;
      __domain->data_i_index.getValue()->resize(_diindex_size);
      __domain->set_data_i_index(__arr);
   }
}

void xios_xml_set_domain_djindex(XPtr const _domain, XDType _dtype,
                                 int _djindex[], XSize _djindex_size)
{
   Array<int, 1> __arr(_djindex, shape(_djindex_size), neverDeleteData, FortranArray<1>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      DomainGroup * __domain = (DomainGroup *) _domain;
      __domain->data_j_index.getValue()->resize(_djindex_size);
      __domain->set_data_j_index(__arr);
   } else {
      CDomain * __domain = (CDomain *) _domain;
      __domain->data_j_index.getValue()->resize(_djindex_size);
      __domain->set_data_j_index(__arr);
   }
}

void xios_xml_set_domain_lonvalue(XPtr const _domain, XDType _dtype, double _lonvalue[],
                                  XSize _lonvalue_Xsize, XSize _lonvalue_Ysize)
{
   XSize __size = (_lonvalue_Ysize == -1)
                  ? _lonvalue_Xsize : (_lonvalue_Ysize*_lonvalue_Xsize);
   Array<double, 1> __arr(_lonvalue, shape(__size), neverDeleteData, FortranArray<1>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      DomainGroup * __domain = (DomainGroup *) _domain;
      __domain->lonvalue.getValue()->resize(__size);
      __domain->set_lonvalue(__arr);
   } else {
      CDomain * __domain = (CDomain *) _domain;
      __domain->lonvalue.getValue()->resize(__size);
      __domain->set_lonvalue(__arr);
   }
}

void xios_xml_set_domain_latvalue(XPtr const _domain, XDType _dtype, double _latvalue[],
                                  XSize _latvalue_Xsize, XSize _latvalue_Ysize)
{
   XSize __size = (_latvalue_Ysize == -1)
                  ? _latvalue_Xsize : (_latvalue_Ysize*_latvalue_Xsize);
   Array<double, 1> __arr(_latvalue, shape(__size), neverDeleteData, FortranArray<1>());
   if (_dtype >= 10 && _dtype <= 14)
   {
      DomainGroup * __domain = (DomainGroup *) _domain;
      __domain->latvalue.getValue()->resize(__size);
      __domain->set_latvalue(__arr);
   } else {
      CDomain * __domain = (CDomain *) _domain;
      __domain->latvalue.getValue()->resize(__size);
      __domain->set_latvalue(__arr);
   }
}

XML_SET_STRING(Domain, domain, domtype, domtype)

/* ********************************************************** */
/*                   DATA TREATMENT INTERFACE                 */
/* ********************************************************** */
static std::vector<DataTreatment *> AllDataTreatment;

static void deleteAllDataTreatment(void)
{
   std::vector<DataTreatment *>::iterator it;
   for (it  = AllDataTreatment.begin();
        it != AllDataTreatment.end(); it++)
      if (*it != NULL) delete (*it);
}

void xios_dtreatment_start(XPtr const _context, XFileType filetype)
{
   static bool called = false;
   Context       * const __ctxt = (Context *) _context;
   DataTreatment * const __dtrt =__ctxt->setDataTreatment<DataTreatment>();
   if (__dtrt != NULL)
   {
      AllDataTreatment.push_back(__dtrt);
      if (!called)
      {
         atexit (&deleteAllDataTreatment);
         called = true;
      }
      switch(filetype)
      {
         case (NETCDF4):
            __dtrt->createDataOutput<NetCDF4DataOutput>();
            return;
         // Autres formats de fichiers si disponibles...
         default:
            return;
      }
   }
}

void xios_dtreatment_end(void)
{


}

void xios_write_data(const XString _field_id, XSize _field_id_len, double * data_k8,
                     XSize data_Xsize, XSize data_Ysize, XSize data_Zsize)
{
   MAKE_STRING(__field_id, _field_id, _field_id_len);

   Context          * const __ctxt = Context::GetCurrentContext();
   DataTreatment    * __dtrt = __ctxt->getDataTreatment();
   AbstractCalendar * __cald = __ctxt->getCalendar();
   if (__dtrt != NULL)
   {
      std::cout << "> Itération de calcul effectuée à  la date t = " << __cald->getCurrentDate()
                << " (soit aprÚs " << (Time)__cald->getCurrentDate() << " sec.)." << std::endl;
      std::cout << __field_id << " : "
                << data_Xsize << " : "
                << data_Ysize << " : "
                << data_Zsize << std::endl;
      if ((data_Zsize == -1) && (data_Ysize == -1))
      { // cas 1D
         Array<double, 1> __arr(data_k8, shape(data_Xsize),
                                neverDeleteData, FortranArray<1>());
         __dtrt->writeData<Array<double, 1> >(__field_id, __arr);
      }
      else if (data_Zsize == -1)
      { // cas 2D
         Array<double, 2> __arr(data_k8, shape(data_Xsize, data_Ysize),
                                neverDeleteData, FortranArray<2>());
         __dtrt->writeData<Array<double, 2> >(__field_id, __arr);
      }
      else
      { // cas 3D
         Array<double, 3> __arr(data_k8, shape(data_Xsize, data_Ysize, data_Zsize),
                                neverDeleteData, FortranArray<3>());
         __dtrt->writeData<Array<double, 3> >(__field_id, __arr);
      }
   }
}

/* ********************************************************** */
/*                      CALENDAR INTERFACE                    */
/* ********************************************************** */

void xios_update_calendar(int step)
{
   Context * current = Context::GetCurrentContext();
   AbstractCalendar * calendar =  current->getCalendar();
   if (current->getDataTreatment() == NULL)
   {
      std::cerr << "Error : Le traitement n'a pas été effectué" << std::endl;
      return;
   }
   calendar->update();
}

void xios_set_timestep(double ts_year, double ts_month, double ts_day,
                       double ts_hour, double ts_minute, double ts_second)
{
   Context * current = Context::GetCurrentContext();
   AbstractCalendar * calendar =  current->getCalendar();
   struct _duration dr = { ts_year, ts_month , ts_day,
                           ts_hour, ts_minute, ts_second };
   if (current->getDataTreatment() == NULL)
   {
      std::cerr << "Error : Le traitement n'a pas été effectué" << std::endl;
      return;
   }
   calendar->setTimeStep(dr);
}

#undef XML_SET
#undef XML_SET_STRING
#undef isNullHandle