Ignore:
Timestamp:
11/17/10 14:40:14 (14 years ago)
Author:
hozdoba
Message:

mise à jour

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp

    r134 r137  
    22 
    33/* ********************************************************** */ 
    4 /*                      CONVERSION FUNCTION                   */ 
    5 /* ********************************************************** */ 
    6  
    7 static inline std::string stringXtoStd(const XString _str) 
    8 { 
    9    char * const temp = new char[_str.len+1](); 
    10    memset(temp, '\0', _str.len+1); 
    11    memcpy(temp, _str.str, _str.len); 
    12    std::string _retstr(temp); 
    13    size_t d = _retstr.find_first_not_of(' '); 
    14    size_t f = _retstr.find_last_not_of (' '); 
    15  
    16    delete[] temp; 
    17    return (_retstr.substr(d, f-d+1)); 
    18 } 
    19  
    20 static inline XString stringXtoStd(const std::string& _str) // Non testée 
    21 { 
    22    XString _retstr = {new char[_str.size()](), _str.size()}; 
    23    memcpy(_retstr.str, _str.c_str(), _str.size()); 
    24    return (_retstr); 
    25 } 
    26  
    27 static inline Duration durationXtoXMLIO(const XDuration * const _xdur) // Non testée 
    28 { 
    29    Duration __dur= { _xdur->year, _xdur->month , _xdur->day, 
    30                      _xdur->hour, _xdur->minute, _xdur->second }; 
    31    return (__dur); 
    32 } 
    33  
    34 /* ********************************************************** */ 
    354/*                      HANDLE INTERFACE                      */ 
    365/* ********************************************************** */ 
    376 
    38 void xios_handle_create_(XHandle * const _ret, const XDType * const _dtype, const XString _id) 
    39 { 
    40    // Si le handle n'est pas initialisé à 0, on ne fait aucun traitement. 
    41    if (!isNullHandle(*_ret)) return; 
    42    std::string __id = stringXtoStd(_id); 
    43    switch(*_dtype) 
    44    { 
    45       /* EAXIS, EDOMAIN, EFIELD, EFILE, EGRID, GAXIS, GDOMAIN, GFIELD, GFILE, GGRID*/ 
     7#define CASE_ELEM(elem_enum, elem_class)                    \ 
     8         case (E##elem_enum):                               \ 
     9            *_ret = (!C##elem_class::HasObject(__id)) ?     \ 
     10               0 : C##elem_class::GetObject(__id);          \ 
     11            return;                                         \ 
     12         case (G##elem_enum):                               \ 
     13            *_ret = (!elem_class##Group::HasObject(__id)) ? \ 
     14               0 : elem_class##Group::GetObject(__id);      \ 
     15            return; 
     16 
     17void xios_handle_create (XPtr * const _ret, XDType _dtype, 
     18                         const XString _id, XSize _id_len) 
     19{ 
     20   MAKE_STRING(__id, _id, _id_len); 
     21   switch(_dtype) 
     22   { 
    4623      case (ECONTEXT): 
    4724         // Si le context n'existe pas, on retourne un handle vide/nul. 
    48          if (!Context::HasContext(__id)) { *_ret = NULLHANDLE; return ; } 
    49          _ret->data_type = *_dtype; 
    50          _ret->data_ptr  = Context::GetContext(__id); 
     25         *_ret = (!Context::HasContext(__id)) ? 0 : Context::GetContext(__id) ; 
    5126         return ; 
    52  
     27      CASE_ELEM(AXIS   , Axis); 
     28      CASE_ELEM(DOMAIN , Domain); 
     29      CASE_ELEM(FIELD  , Field); 
     30      CASE_ELEM(FILE   , File); 
     31      CASE_ELEM(GRID   , Grid); 
    5332      default : 
    54          *_ret = NULLHANDLE; 
     33         *_ret = 0; 
    5534         return ; 
    5635   }; 
    5736} 
    5837 
     38#undef CASE_ELEM 
     39 
    5940/* ********************************************************** */ 
    6041/*                      XML INTERFACE                         */ 
    6142/* ********************************************************** */ 
    6243 
    63 void xios_xml_parse_file_(const XString _filename) 
    64 { 
    65    std::string   __filename = stringXtoStd(_filename); 
     44void xios_xml_parse_file(const XString _filename, XSize _filename_len) 
     45{ 
     46   MAKE_STRING(__filename, _filename, _filename_len); 
    6647   std::ifstream __istr( __filename.c_str() , std::ifstream::in ); 
    6748 
    6849   // On commence la lecture du flux de donnée xml. 
    6950   XMLNode node = XMLNode::CreateNode(__istr, Context::GetRootName()); 
    70  
    7151   // On parse le fichier xml noeud par noeud 
    7252   // (ie on construit dynamiquement notre arbre d'objets). 
    7353   XMLParser::Parse(node); 
    74 } 
    75  
    76 void xios_xml_parse_string_(const XString _xmlcontent) 
    77 { 
    78    std::string        __xmlcontent = stringXtoStd(_xmlcontent); 
     54 
     55} 
     56 
     57void xios_xml_parse_string(const XString _xmlcontent, XSize _xmlcontent_len) 
     58{ 
     59   MAKE_STRING(__xmlcontent, _xmlcontent, _xmlcontent_len); 
    7960   std::istringstream __istr(__xmlcontent); 
    8061 
    8162   // On commence la lecture du flux de donnée xml. 
    8263   XMLNode node = XMLNode::CreateNode(__istr, Context::GetRootName()); 
    83  
    84    // On parse le fichier xml noeud par noeud 
    85    // (ie on construit dynamiquement notre arbre d'objets). 
     64   // On parse le document xml noeud par noeud 
    8665   XMLParser::Parse(node); 
    8766} 
    88  
    89 /* ********************************************************** */ 
    90 /*                      DATA TREATMENT INTERFACE              */ 
    91 /* ********************************************************** */ 
    92  
     67/* ********************************************************** */ 
     68/*                      CONTEXT INTERFACE                     */ 
     69/* ********************************************************** */ 
     70 
     71void xios_context_set_current (XPtr _ctx, bool _wswap) 
     72{ 
     73   Context* const __ctxt = (Context*) _ctx; 
     74   Context::SetCurrentContext(__ctxt->getId(), _wswap) ; 
     75} 
     76 
     77void xios_context_create (XPtr * _ctx, const XString _ctx_id, 
     78                          XSize _ctx_id_len, XCalendarType _calType) 
     79{ 
     80   MAKE_STRING(__ctx_id, _ctx_id, _ctx_id_len); 
     81   // si le contexte existe déjà, on arrête le traitement. 
     82   if (Context::HasContext(__ctx_id)) { _ctx = NULL; return ; } 
     83 
     84   Context::SetCurrentContext(__ctx_id, false, false); 
     85   Context * context = Context::CreateObject(__ctx_id); 
     86   context->createDefinitions(); *_ctx = context; 
     87 
     88   if (!Context::HasContext(__ctx_id)) // Au cas où ... 
     89      std::cerr << "La création du contexte a échoué ???" << std::endl; 
     90 
     91   switch(_calType) 
     92   { 
     93      case (D360) : 
     94         context->setCalendar(new D360Calendar());      return; 
     95      case (ALLLEAP) : 
     96         context->setCalendar(new AllLeapCalendar());   return; 
     97      case (NOLEAP) : 
     98         context->setCalendar(new NoLeapCalendar());    return; 
     99      case (JULIAN) : 
     100         context->setCalendar(new JulianCalendar());    return; 
     101      case (GREGORIAN) : 
     102         context->setCalendar(new GregorianCalendar()); return; 
     103      default: 
     104         std::cerr << "[context_create] Type de calendrier invalide [0-5]" << std::endl; 
     105         return; 
     106   } 
     107} 
     108 
     109/* ********************************************************** */ 
     110/*                    XML TREE INTERFACE                      */ 
     111/* ********************************************************** */ 
     112 
     113#define CASE_ELEM0(elem_enum, elem_class, group_enum, group_class)              \ 
     114      case (group_enum) : {                                                     \ 
     115         group_class * _group = (group_class *) _parent;                        \ 
     116         switch(_child_type) {                                                  \ 
     117            case (group_enum) :                                                 \ 
     118               if ((_child_id_len != -1) &&                                     \ 
     119                   (group_class::HasObject(___child_id))) return;               \ 
     120               *_child = (_child_id_len != -1)                                  \ 
     121                       ? (group_class *)(&_group->createGroup(___child_id))     \ 
     122                       : (group_class *)(&_group->createGroup());               \ 
     123               break;                                                           \ 
     124            case (elem_enum) :                                                  \ 
     125               if ((_child_id_len != -1) &&                                     \ 
     126                   (elem_class::HasObject(___child_id))) return;                \ 
     127               *_child = (_child_id_len != -1)                                  \ 
     128                       ? (elem_class *)(&_group->createChild(___child_id))      \ 
     129                       : (elem_class *)(&_group->createChild());                \ 
     130               break;                                                           \ 
     131            default :                                                           \ 
     132               std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; \ 
     133         }; return; } 
     134 
     135void xios_xml_tree_add (const XPtr _parent, XDType _parent_type, XPtr * _child, 
     136                        XDType _child_type, const XString _child_id, XSize _child_id_len) 
     137{ 
     138   string ___child_id; 
     139   if (_child_id_len != -1) 
     140   { 
     141      MAKE_STRING(__child_id, _child_id, _child_id_len); 
     142      ___child_id = __child_id; 
     143   } 
     144 
     145   switch (_parent_type) 
     146   { 
     147      case (EFILE) : 
     148      { 
     149         CFile * _file = (CFile *) _parent; 
     150         FieldGroup * _field_group = _file->createVirtualFieldGroup(_file->getId()); 
     151         xios_xml_tree_add (_field_group, GFIELD, _child, _child_type, _child_id, _child_id_len); 
     152         return; 
     153      } 
     154      CASE_ELEM0(EAXIS, CAxis, GAXIS, AxisGroup); 
     155      CASE_ELEM0(EGRID, CGrid, GGRID, GridGroup); 
     156      CASE_ELEM0(EDOMAIN, CDomain, GDOMAIN, DomainGroup); 
     157      CASE_ELEM0(EFIELD, CField, GFIELD, FieldGroup); 
     158      CASE_ELEM0(EFILE, CFile, GFILE, FileGroup); 
     159      default : 
     160         std::cerr << "[xml_tree_add] Type parent invalide" << std::endl; 
     161         return; 
     162   } 
     163} 
     164 
     165#undef CASE_ELEM0 
     166 
     167void xios_xml_tree_show(const XString _filename, XSize _filename_len) 
     168{ 
     169   string ___filename; 
     170   if (_filename_len != -1) 
     171   { 
     172      MAKE_STRING(__filename, _filename, _filename_len); 
     173      ___filename = __filename; 
     174   } 
     175   if (_filename_len == -1) 
     176      // On écrit l'arborescence résultante du traitement sur la sortie de log. 
     177      Context::ShowTree(std::clog); 
     178   else 
     179   { 
     180      std::ofstream __outfile (___filename.c_str()); 
     181      // On écrit l'arborescence résultante du traitement dans le fichier. 
     182      Context::ShowTree(__outfile); 
     183      __outfile.close(); 
     184   } 
     185} 
     186 
     187#undef XML_SET 
     188#undef XML_SET_STRING 
     189 
     190#define XML_SET(ttype, type, type_var, var, long_var)                 \ 
     191   void xios_xml_set_##type##_##var                                   \ 
     192                  (XPtr const _##type, XDType _dtype, type_var var){  \ 
     193      if (_dtype >= 10 && _dtype <= 14) {                             \ 
     194         ttype##Group * __##type = (ttype##Group *) _##type;          \ 
     195         __##type->set_##long_var(var);                               \ 
     196      } else {                                                        \ 
     197         C##ttype * __##type = (C##ttype *) _##type;                  \ 
     198         __##type->set_##long_var(var);                               \ 
     199   }} 
     200 
     201 
     202#define XML_SET_STRING(ttype, type, var, long_var)              \ 
     203   void xios_xml_set_##type##_##var(XPtr const _##type,         \ 
     204      XDType _dtype, const XString _##var, XSize _##var##_len) {\ 
     205      MAKE_STRING(___##var, _##var, _##var##_len);              \ 
     206      if (_dtype >= 10 && _dtype <= 14) {                       \ 
     207         ttype##Group * __##type = (ttype##Group *) _##type;    \ 
     208         __##type->set_##long_var(___##var);                    \ 
     209      } else {                                                  \ 
     210         C##ttype * __##type = (C##ttype *) _##type;            \ 
     211         __##type->set_##long_var(___##var);                    \ 
     212   }} 
     213 
     214// Attributs de field ou field_group // 
     215XML_SET_STRING(Field, field, name, name) 
     216XML_SET_STRING(Field, field, sname, standard_name) 
     217XML_SET_STRING(Field, field, lname, long_name) 
     218XML_SET_STRING(Field, field, unit, unit) 
     219XML_SET_STRING(Field, field, operation, operation) 
     220 
     221void xios_xml_set_field_freq_op(XPtr const _field, XDType _dtype, 
     222                                double year, double month, double day, 
     223                                double hour, double minute, double second) 
     224{ 
     225   const Duration _dur   = {year, month, day, hour, minute, second}; 
     226   if (_dtype >= 10 && _dtype <= 14) 
     227   { 
     228      FieldGroup * __field = (FieldGroup *) _field; 
     229      __field->set_freq_op(_dur); 
     230   } else { 
     231      CField * __field = (CField *) _field; 
     232      __field->set_freq_op(_dur); 
     233   } 
     234} 
     235 
     236XML_SET(Field, field, int, level, level) 
     237XML_SET(Field, field, int, prec, prec) 
     238XML_SET(Field, field, bool, enabled, enabled) 
     239 
     240XML_SET_STRING(Field, field, dref, domain_ref) 
     241XML_SET_STRING(Field, field, aref, axis_ref) 
     242XML_SET_STRING(Field, field, gref, grid_ref) 
     243XML_SET_STRING(Field, field, zref, zoom_ref) 
     244XML_SET_STRING(Field, field, fref, field_ref) 
     245 
     246// Attributs de file ou file_group 
     247XML_SET_STRING(File, file, name, name) 
     248XML_SET_STRING(File, file, description, description) 
     249 
     250void xios_xml_set_file_output_freq(XPtr const _file, XDType _dtype, 
     251                                   double year, double month, double day, 
     252                                   double hour, double minute, double second) 
     253{ 
     254   const Duration _dur   = {year, month, day, hour, minute, second}; 
     255   if (_dtype >= 10 && _dtype <= 14) 
     256   { 
     257      FileGroup * __file = (FileGroup *) _file; 
     258      __file->set_output_freq(_dur); 
     259   } else { 
     260      CFile * __file= (CFile *) _file; 
     261      __file->set_output_freq(_dur); 
     262   } 
     263} 
     264 
     265XML_SET(File, file, int, olevel, output_level) 
     266XML_SET(File, file, bool, enabled, enabled) 
     267 
     268// Attributs de grid ou grid_group 
     269XML_SET_STRING(Grid, grid, name, name) 
     270XML_SET_STRING(Grid, grid, description, description) 
     271XML_SET_STRING(Grid, grid, dref, domain_ref) 
     272XML_SET_STRING(Grid, grid, aref, axis_ref) 
     273 
     274// Attribut de axis ou axis group 
     275XML_SET_STRING(Axis, axis, name, name) 
     276XML_SET_STRING(Axis, axis, sname, standard_name) 
     277XML_SET_STRING(Axis, axis, lname, long_name) 
     278 
     279XML_SET_STRING(Axis, axis, unit, unit) 
     280 
     281void xios_xml_set_axis_value(XPtr const _axis, XDType _dtype, double value[], XSize value_size) 
     282{ 
     283   Array<double, 1> __arr(value, shape(value_size), neverDeleteData, FortranArray<1>()); 
     284   if (_dtype >= 10 && _dtype <= 14) 
     285   { 
     286      AxisGroup * __axis = (AxisGroup *) _axis; 
     287      __axis->set_size(value_size); 
     288      __axis->zvalue.getValue()->resize(value_size); 
     289      __axis->set_zvalue(__arr); 
     290   } else { 
     291      CAxis * __axis = (CAxis *) _axis; 
     292      __axis->set_size(value_size); 
     293      __axis->zvalue.getValue()->resize(value_size); 
     294      __axis->set_zvalue(__arr); 
     295   } 
     296} 
     297 
     298// Attribut de domain ou domain_group 
     299XML_SET_STRING(Domain, domain, name, name) 
     300XML_SET_STRING(Domain, domain, sname, standard_name) 
     301XML_SET_STRING(Domain, domain, lname, long_name) 
     302 
     303XML_SET(Domain, domain, int, niglo, ni_glo) 
     304XML_SET(Domain, domain, int, njglo, nj_glo) 
     305 
     306XML_SET(Domain, domain, int, ibegin, ibegin) 
     307XML_SET(Domain, domain, int, iend, iend) 
     308XML_SET(Domain, domain, int, ni, ni) 
     309 
     310XML_SET(Domain, domain, int, jbegin, jbegin) 
     311XML_SET(Domain, domain, int, jend, jend) 
     312XML_SET(Domain, domain, int, nj, nj) 
     313 
     314void xios_xml_set_domain_mask(XPtr const _domain, XDType _dtype, bool * _mask , XSize _maskXsize, XSize _maskYsize) 
     315{ 
     316   Array<bool, 2> __arr(_mask, shape(_maskXsize, _maskYsize), neverDeleteData, FortranArray<2>()); 
     317   if (_dtype >= 10 && _dtype <= 14) 
     318   { 
     319      DomainGroup * __domain = (DomainGroup *) _domain; 
     320      __domain->mask.getValue()->resize(shape(_maskXsize, _maskYsize)); 
     321      __domain->set_mask(__arr); 
     322   } else { 
     323      CDomain * __domain = (CDomain *) _domain; 
     324      __domain->mask.getValue()->resize(shape(_maskXsize, _maskYsize)); 
     325      __domain->set_mask(__arr); 
     326   } 
     327 
     328} 
     329 
     330XML_SET(Domain, domain, int, ddim, data_dim) 
     331XML_SET(Domain, domain, int, dni, data_ni) 
     332XML_SET(Domain, domain, int, dnj, data_nj) 
     333XML_SET(Domain, domain, int, dibegin, data_ibegin) 
     334XML_SET(Domain, domain, int, djbegin, data_jbegin) 
     335 
     336XML_SET(Domain, domain, int, dnindex, data_n_index) 
     337 
     338void xios_xml_set_domain_diindex(XPtr const _domain, XDType _dtype, int _diindex[], XSize _diindex_size) 
     339{ 
     340   Array<int, 1> __arr(_diindex, shape(_diindex_size), neverDeleteData, FortranArray<1>()); 
     341   if (_dtype >= 10 && _dtype <= 14) 
     342   { 
     343      DomainGroup * __domain = (DomainGroup *) _domain; 
     344      __domain->data_i_index.getValue()->resize(_diindex_size); 
     345      __domain->set_data_i_index(__arr); 
     346   } else { 
     347      CDomain * __domain = (CDomain *) _domain; 
     348      __domain->data_i_index.getValue()->resize(_diindex_size); 
     349      __domain->set_data_i_index(__arr); 
     350   } 
     351} 
     352 
     353void xios_xml_set_domain_djindex(XPtr const _domain, XDType _dtype, int _djindex[], XSize _djindex_size) 
     354{ 
     355   Array<int, 1> __arr(_djindex, shape(_djindex_size), neverDeleteData, FortranArray<1>()); 
     356   if (_dtype >= 10 && _dtype <= 14) 
     357   { 
     358      DomainGroup * __domain = (DomainGroup *) _domain; 
     359      __domain->data_j_index.getValue()->resize(_djindex_size); 
     360      __domain->set_data_j_index(__arr); 
     361   } else { 
     362      CDomain * __domain = (CDomain *) _domain; 
     363      __domain->data_j_index.getValue()->resize(_djindex_size); 
     364      __domain->set_data_j_index(__arr); 
     365   } 
     366} 
     367 
     368void xios_xml_set_domain_lonvalue(XPtr const _domain, XDType _dtype, double _lonvalue[], XSize _lonvalue_Xsize, XSize _lonvalue_Ysize) 
     369{ 
     370   XSize __size = (_lonvalue_Ysize == -1) 
     371                  ? _lonvalue_Xsize : (_lonvalue_Ysize*_lonvalue_Xsize); 
     372   Array<double, 1> __arr(_lonvalue, shape(__size), neverDeleteData, FortranArray<1>()); 
     373   if (_dtype >= 10 && _dtype <= 14) 
     374   { 
     375      DomainGroup * __domain = (DomainGroup *) _domain; 
     376      __domain->lonvalue.getValue()->resize(__size); 
     377      __domain->set_lonvalue(__arr); 
     378   } else { 
     379      CDomain * __domain = (CDomain *) _domain; 
     380      __domain->lonvalue.getValue()->resize(__size); 
     381      __domain->set_lonvalue(__arr); 
     382   } 
     383} 
     384 
     385void xios_xml_set_domain_latvalue(XPtr const _domain, XDType _dtype, double _latvalue[], XSize _latvalue_Xsize, XSize _latvalue_Ysize) 
     386{ 
     387   XSize __size = (_latvalue_Ysize == -1) 
     388                  ? _latvalue_Xsize : (_latvalue_Ysize*_latvalue_Xsize); 
     389   Array<double, 1> __arr(_latvalue, shape(__size), neverDeleteData, FortranArray<1>()); 
     390   if (_dtype >= 10 && _dtype <= 14) 
     391   { 
     392      DomainGroup * __domain = (DomainGroup *) _domain; 
     393      __domain->latvalue.getValue()->resize(__size); 
     394      __domain->set_latvalue(__arr); 
     395   } else { 
     396      CDomain * __domain = (CDomain *) _domain; 
     397      __domain->latvalue.getValue()->resize(__size); 
     398      __domain->set_latvalue(__arr); 
     399   } 
     400} 
     401 
     402XML_SET_STRING(Domain, domain, domtype, domtype) 
     403 
     404/* ********************************************************** */ 
     405/*                   DATA TREATMENT INTERFACE                 */ 
     406/* ********************************************************** */ 
    93407static std::vector<DataTreatment *> AllDataTreatment; 
    94408 
    … …  
    101415} 
    102416 
    103 void xios_dtreatment_new_(XHandle * const _dt, const XHandle * const _hd) 
     417void xios_dtreatment_start(XPtr const _context, XFileType filetype) 
    104418{ 
    105419   static bool called = false; 
    106  
    107    // Si le handle de traitement n'est pas initialisé à 0, on ne fait aucun traitement. 
    108    if (!isNullHandle(*_dt) || (_hd->data_type != ECONTEXT)) return; 
    109    Context       * const __ctxt = (Context*) _hd->data_ptr; 
     420   Context       * const __ctxt = (Context *) _context; 
    110421   DataTreatment * const __dtrt =__ctxt->setDataTreatment<DataTreatment>(); 
    111  
    112422   if (__dtrt != NULL) 
    113423   { 
    114424      AllDataTreatment.push_back(__dtrt); 
    115       _dt->data_type = DTREATMENT; 
    116       _dt->data_ptr  = __dtrt; 
    117425      if (!called) 
    118426      { 
    … …  
    123431} 
    124432 
    125 void xios_dtreatment_create_files_and_headers_(const XHandle * const _hd, const XFileType * const _ft) 
    126 { 
    127    if (isNullHandle(*_hd) || (_hd->data_type != DTREATMENT)) return; 
    128    DataTreatment * const __dt = (DataTreatment*)_hd->data_ptr; 
    129    switch(*_ft) 
    130    { 
    131       case (NETCDF4): 
    132          __dt->createDataOutput<NetCDF4DataOutput>(); 
    133          return; 
    134       // Autres formats de fichiers si disponibles... 
    135       default: 
    136          return; 
    137    } 
    138 } 
    139  
    140 /* ********************************************************** */ 
    141 /*                      CONTEXT INTERFACE                     */ 
    142 /* ********************************************************** */ 
    143  
    144 void xios_context_set_current_(const XHandle * const _ctxt, const bool * const _wswap) 
    145 { 
    146    bool __wswap = (_wswap == NULL) ? false : *_wswap; 
    147    if (isNullHandle(*_ctxt) || (_ctxt->data_type != ECONTEXT)) return; 
    148    Context* const __ctxt = (Context*) _ctxt->data_ptr; 
    149    Context::SetCurrentContext(__ctxt->getId(), __wswap) ; 
    150 } 
    151  
    152 void xios_context_get_current_ (XHandle * _ctxt) 
    153 { 
    154    // Si le handle de traitement n'est pas initialisé à 0, on ne fait aucun traitement. 
    155    if ((Context::GetAllListObject().size() == 0) || 
    156          !isNullHandle(*_ctxt)) return; 
    157    _ctxt->data_type = ECONTEXT; 
    158    _ctxt->data_ptr  = Context::GetCurrentContext(); 
    159 } 
    160  
    161 void xios_context_get_calendar_(const XHandle * const _ctxt, XHandle * _cal) 
    162 { 
    163    if (!isNullHandle(*_cal)  || isNullHandle(*_ctxt) || 
    164       (_ctxt->data_type != ECONTEXT)) return; 
    165    Context* const __ctxt = (Context*) _ctxt->data_ptr; 
    166    AbstractCalendar * const __cal  = __ctxt->getCalendar(); 
    167    if (__cal != NULL) 
    168    { 
    169       _cal->data_type = CALENDAR; 
    170       _cal->data_ptr  = __cal; 
    171    } 
    172 } 
    173  
    174 /* ********************************************************** */ 
    175 /*                      CALENDAR INTERFACE                    */ 
    176 /* ********************************************************** */ 
    177  
    178 void xios_calendar_set_timestep_(const XHandle * const _cal, const XDuration * const _dur) 
    179 { 
    180    if (isNullHandle(*_cal) || (_cal->data_type != CALENDAR)) return; 
    181    const Duration __dur = durationXtoXMLIO(_dur); 
    182    AbstractCalendar * const __cal = (AbstractCalendar*) _cal->data_ptr; 
    183    __cal->setTimeStep(__dur); 
    184 } 
    185  
     433#undef XML_SET 
     434#undef XML_SET_STRING 
    186435#undef isNullHandle 
Note: See TracChangeset for help on using the changeset viewer.