Ignore:
Timestamp:
03/24/15 11:21:45 (9 years ago)
Author:
rlacroix
Message:

Fix the Fortran interface generation to avoid generating dead code that caused a timer not to be stopped.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

    r538 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CFieldGroup*  fieldgroup_Ptr; 
    19    
     18  typedef xios::CFieldGroup* fieldgroup_Ptr; 
     19 
    2020  void cxios_set_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl, double add_offset) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    fieldgroup_hdl->add_offset.setValue(add_offset); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl, double* add_offset) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *add_offset = fieldgroup_hdl->add_offset.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return fieldgroup_hdl->add_offset.hasInheritedValue(); 
    36      CTimer::get("XIOS").suspend(); 
    37   } 
    38    
    39    
    40    
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = fieldgroup_hdl->add_offset.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, const char * axis_ref, int axis_ref_size) 
    4244  { 
    4345    std::string axis_ref_str; 
    44     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    45      CTimer::get("XIOS").resume(); 
     46    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     47    CTimer::get("XIOS").resume(); 
    4648    fieldgroup_hdl->axis_ref.setValue(axis_ref_str); 
    47      CTimer::get("XIOS").suspend(); 
    48   } 
    49    
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
    5052  void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size) 
    5153  { 
    52      CTimer::get("XIOS").resume(); 
    53     if(!string_copy(fieldgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    54       ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    55      CTimer::get("XIOS").suspend(); 
    56   } 
    57    
    58   bool cxios_is_defined_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return fieldgroup_hdl->axis_ref.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(fieldgroup_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size)) 
     56      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = fieldgroup_hdl->axis_ref.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value) 
    6870  { 
    69      CTimer::get("XIOS").resume(); 
     71    CTimer::get("XIOS").resume(); 
    7072    fieldgroup_hdl->default_value.setValue(default_value); 
    71      CTimer::get("XIOS").suspend(); 
    72   } 
    73    
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
    7476  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value) 
    7577  { 
     78    CTimer::get("XIOS").resume(); 
    7679    *default_value = fieldgroup_hdl->default_value.getInheritedValue(); 
    77   } 
    78    
    79   bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl ) 
    80   { 
    81      CTimer::get("XIOS").resume(); 
    82     return fieldgroup_hdl->default_value.hasInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85    
    86    
    87    
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = fieldgroup_hdl->default_value.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
     90 
     91 
    8892  void cxios_set_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool detect_missing_value) 
    8993  { 
    90      CTimer::get("XIOS").resume(); 
     94    CTimer::get("XIOS").resume(); 
    9195    fieldgroup_hdl->detect_missing_value.setValue(detect_missing_value); 
    92      CTimer::get("XIOS").suspend(); 
    93   } 
    94    
     96    CTimer::get("XIOS").suspend(); 
     97  } 
     98 
    9599  void cxios_get_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool* detect_missing_value) 
    96100  { 
     101    CTimer::get("XIOS").resume(); 
    97102    *detect_missing_value = fieldgroup_hdl->detect_missing_value.getInheritedValue(); 
    98   } 
    99    
    100   bool cxios_is_defined_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl ) 
    101   { 
    102      CTimer::get("XIOS").resume(); 
    103     return fieldgroup_hdl->detect_missing_value.hasInheritedValue(); 
    104      CTimer::get("XIOS").suspend(); 
    105   } 
    106    
    107    
    108    
     103    CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  bool cxios_is_defined_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl) 
     107  { 
     108     CTimer::get("XIOS").resume(); 
     109     bool isDefined = fieldgroup_hdl->detect_missing_value.hasInheritedValue(); 
     110     CTimer::get("XIOS").suspend(); 
     111     return isDefined; 
     112  } 
     113 
     114 
    109115  void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, const char * domain_ref, int domain_ref_size) 
    110116  { 
    111117    std::string domain_ref_str; 
    112     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    113      CTimer::get("XIOS").resume(); 
     118    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     119    CTimer::get("XIOS").resume(); 
    114120    fieldgroup_hdl->domain_ref.setValue(domain_ref_str); 
    115      CTimer::get("XIOS").suspend(); 
    116   } 
    117    
     121    CTimer::get("XIOS").suspend(); 
     122  } 
     123 
    118124  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size) 
    119125  { 
    120      CTimer::get("XIOS").resume(); 
    121     if(!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    122       ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    123      CTimer::get("XIOS").suspend(); 
    124   } 
    125    
    126   bool cxios_is_defined_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl ) 
    127   { 
    128      CTimer::get("XIOS").resume(); 
    129     return fieldgroup_hdl->domain_ref.hasInheritedValue(); 
    130      CTimer::get("XIOS").suspend(); 
    131   } 
    132    
    133    
    134    
     126    CTimer::get("XIOS").resume(); 
     127    if (!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size)) 
     128      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short"); 
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = fieldgroup_hdl->domain_ref.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    135141  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled) 
    136142  { 
    137      CTimer::get("XIOS").resume(); 
     143    CTimer::get("XIOS").resume(); 
    138144    fieldgroup_hdl->enabled.setValue(enabled); 
    139      CTimer::get("XIOS").suspend(); 
    140   } 
    141    
     145    CTimer::get("XIOS").suspend(); 
     146  } 
     147 
    142148  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled) 
    143149  { 
     150    CTimer::get("XIOS").resume(); 
    144151    *enabled = fieldgroup_hdl->enabled.getInheritedValue(); 
    145   } 
    146    
    147   bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl ) 
    148   { 
    149      CTimer::get("XIOS").resume(); 
    150     return fieldgroup_hdl->enabled.hasInheritedValue(); 
    151      CTimer::get("XIOS").suspend(); 
    152   } 
    153    
    154    
    155    
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl) 
     156  { 
     157     CTimer::get("XIOS").resume(); 
     158     bool isDefined = fieldgroup_hdl->enabled.hasInheritedValue(); 
     159     CTimer::get("XIOS").suspend(); 
     160     return isDefined; 
     161  } 
     162 
     163 
    156164  void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, const char * field_ref, int field_ref_size) 
    157165  { 
    158166    std::string field_ref_str; 
    159     if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
    160      CTimer::get("XIOS").resume(); 
     167    if (!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
     168    CTimer::get("XIOS").resume(); 
    161169    fieldgroup_hdl->field_ref.setValue(field_ref_str); 
    162      CTimer::get("XIOS").suspend(); 
    163   } 
    164    
     170    CTimer::get("XIOS").suspend(); 
     171  } 
     172 
    165173  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size) 
    166174  { 
    167      CTimer::get("XIOS").resume(); 
    168     if(!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size)) 
    169       ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short"); 
    170      CTimer::get("XIOS").suspend(); 
    171   } 
    172    
    173   bool cxios_is_defined_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl ) 
    174   { 
    175      CTimer::get("XIOS").resume(); 
    176     return fieldgroup_hdl->field_ref.hasInheritedValue(); 
    177      CTimer::get("XIOS").suspend(); 
    178   } 
    179    
    180    
    181    
     175    CTimer::get("XIOS").resume(); 
     176    if (!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(), field_ref, field_ref_size)) 
     177      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", << "Input string is too short"); 
     178    CTimer::get("XIOS").suspend(); 
     179  } 
     180 
     181  bool cxios_is_defined_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl) 
     182  { 
     183     CTimer::get("XIOS").resume(); 
     184     bool isDefined = fieldgroup_hdl->field_ref.hasInheritedValue(); 
     185     CTimer::get("XIOS").suspend(); 
     186     return isDefined; 
     187  } 
     188 
     189 
    182190  void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, cxios_duration freq_offset_c) 
    183191  { 
    … …  
    194202    CTimer::get("XIOS").suspend(); 
    195203  } 
    196    
     204 
    197205  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, cxios_duration* freq_offset_c) 
    198206  { 
    … …  
    208216    CTimer::get("XIOS").suspend(); 
    209217  } 
    210    
    211   bool cxios_is_defined_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl ) 
    212   { 
    213      CTimer::get("XIOS").resume(); 
    214     return fieldgroup_hdl->freq_offset.hasInheritedValue(); 
    215      CTimer::get("XIOS").suspend(); 
    216   } 
    217    
    218    
    219    
     218 
     219  bool cxios_is_defined_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl) 
     220  { 
     221     CTimer::get("XIOS").resume(); 
     222     bool isDefined = fieldgroup_hdl->freq_offset.hasInheritedValue(); 
     223     CTimer::get("XIOS").suspend(); 
     224     return isDefined; 
     225  } 
     226 
     227 
    220228  void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, cxios_duration freq_op_c) 
    221229  { 
    … …  
    232240    CTimer::get("XIOS").suspend(); 
    233241  } 
    234    
     242 
    235243  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, cxios_duration* freq_op_c) 
    236244  { 
    … …  
    246254    CTimer::get("XIOS").suspend(); 
    247255  } 
    248    
    249   bool cxios_is_defined_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl ) 
    250   { 
    251      CTimer::get("XIOS").resume(); 
    252     return fieldgroup_hdl->freq_op.hasInheritedValue(); 
    253      CTimer::get("XIOS").suspend(); 
    254   } 
    255    
    256    
    257    
     256 
     257  bool cxios_is_defined_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl) 
     258  { 
     259     CTimer::get("XIOS").resume(); 
     260     bool isDefined = fieldgroup_hdl->freq_op.hasInheritedValue(); 
     261     CTimer::get("XIOS").suspend(); 
     262     return isDefined; 
     263  } 
     264 
     265 
    258266  void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, const char * grid_ref, int grid_ref_size) 
    259267  { 
    260268    std::string grid_ref_str; 
    261     if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
    262      CTimer::get("XIOS").resume(); 
     269    if (!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
     270    CTimer::get("XIOS").resume(); 
    263271    fieldgroup_hdl->grid_ref.setValue(grid_ref_str); 
    264      CTimer::get("XIOS").suspend(); 
    265   } 
    266    
     272    CTimer::get("XIOS").suspend(); 
     273  } 
     274 
    267275  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size) 
    268276  { 
    269      CTimer::get("XIOS").resume(); 
    270     if(!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size)) 
    271       ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short"); 
    272      CTimer::get("XIOS").suspend(); 
    273   } 
    274    
    275   bool cxios_is_defined_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl ) 
    276   { 
    277      CTimer::get("XIOS").resume(); 
    278     return fieldgroup_hdl->grid_ref.hasInheritedValue(); 
    279      CTimer::get("XIOS").suspend(); 
    280   } 
    281    
    282    
    283    
     277    CTimer::get("XIOS").resume(); 
     278    if (!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(), grid_ref, grid_ref_size)) 
     279      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", << "Input string is too short"); 
     280    CTimer::get("XIOS").suspend(); 
     281  } 
     282 
     283  bool cxios_is_defined_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl) 
     284  { 
     285     CTimer::get("XIOS").resume(); 
     286     bool isDefined = fieldgroup_hdl->grid_ref.hasInheritedValue(); 
     287     CTimer::get("XIOS").suspend(); 
     288     return isDefined; 
     289  } 
     290 
     291 
    284292  void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size) 
    285293  { 
    286294    std::string group_ref_str; 
    287     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    288      CTimer::get("XIOS").resume(); 
     295    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     296    CTimer::get("XIOS").resume(); 
    289297    fieldgroup_hdl->group_ref.setValue(group_ref_str); 
    290      CTimer::get("XIOS").suspend(); 
    291   } 
    292    
     298    CTimer::get("XIOS").suspend(); 
     299  } 
     300 
    293301  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size) 
    294302  { 
    295      CTimer::get("XIOS").resume(); 
    296     if(!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    297       ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    298      CTimer::get("XIOS").suspend(); 
    299   } 
    300    
    301   bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl ) 
    302   { 
    303      CTimer::get("XIOS").resume(); 
    304     return fieldgroup_hdl->group_ref.hasInheritedValue(); 
    305      CTimer::get("XIOS").suspend(); 
    306   } 
    307    
    308    
    309    
     303    CTimer::get("XIOS").resume(); 
     304    if (!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     305      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     306    CTimer::get("XIOS").suspend(); 
     307  } 
     308 
     309  bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl) 
     310  { 
     311     CTimer::get("XIOS").resume(); 
     312     bool isDefined = fieldgroup_hdl->group_ref.hasInheritedValue(); 
     313     CTimer::get("XIOS").suspend(); 
     314     return isDefined; 
     315  } 
     316 
     317 
    310318  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level) 
    311319  { 
    312      CTimer::get("XIOS").resume(); 
     320    CTimer::get("XIOS").resume(); 
    313321    fieldgroup_hdl->level.setValue(level); 
    314      CTimer::get("XIOS").suspend(); 
    315   } 
    316    
     322    CTimer::get("XIOS").suspend(); 
     323  } 
     324 
    317325  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level) 
    318326  { 
     327    CTimer::get("XIOS").resume(); 
    319328    *level = fieldgroup_hdl->level.getInheritedValue(); 
    320   } 
    321    
    322   bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl ) 
    323   { 
    324      CTimer::get("XIOS").resume(); 
    325     return fieldgroup_hdl->level.hasInheritedValue(); 
    326      CTimer::get("XIOS").suspend(); 
    327   } 
    328    
    329    
    330    
     329    CTimer::get("XIOS").suspend(); 
     330  } 
     331 
     332  bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl) 
     333  { 
     334     CTimer::get("XIOS").resume(); 
     335     bool isDefined = fieldgroup_hdl->level.hasInheritedValue(); 
     336     CTimer::get("XIOS").suspend(); 
     337     return isDefined; 
     338  } 
     339 
     340 
    331341  void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size) 
    332342  { 
    333343    std::string long_name_str; 
    334     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    335      CTimer::get("XIOS").resume(); 
     344    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     345    CTimer::get("XIOS").resume(); 
    336346    fieldgroup_hdl->long_name.setValue(long_name_str); 
    337      CTimer::get("XIOS").suspend(); 
    338   } 
    339    
     347    CTimer::get("XIOS").suspend(); 
     348  } 
     349 
    340350  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size) 
    341351  { 
    342      CTimer::get("XIOS").resume(); 
    343     if(!string_copy(fieldgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    344       ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    345      CTimer::get("XIOS").suspend(); 
    346   } 
    347    
    348   bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl ) 
    349   { 
    350      CTimer::get("XIOS").resume(); 
    351     return fieldgroup_hdl->long_name.hasInheritedValue(); 
    352      CTimer::get("XIOS").suspend(); 
    353   } 
    354    
    355    
    356    
     352    CTimer::get("XIOS").resume(); 
     353    if (!string_copy(fieldgroup_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     354      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     355    CTimer::get("XIOS").suspend(); 
     356  } 
     357 
     358  bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl) 
     359  { 
     360     CTimer::get("XIOS").resume(); 
     361     bool isDefined = fieldgroup_hdl->long_name.hasInheritedValue(); 
     362     CTimer::get("XIOS").suspend(); 
     363     return isDefined; 
     364  } 
     365 
     366 
    357367  void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size) 
    358368  { 
    359369    std::string name_str; 
    360     if(!cstr2string(name, name_size, name_str)) return; 
    361      CTimer::get("XIOS").resume(); 
     370    if (!cstr2string(name, name_size, name_str)) return; 
     371    CTimer::get("XIOS").resume(); 
    362372    fieldgroup_hdl->name.setValue(name_str); 
    363      CTimer::get("XIOS").suspend(); 
    364   } 
    365    
     373    CTimer::get("XIOS").suspend(); 
     374  } 
     375 
    366376  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size) 
    367377  { 
    368      CTimer::get("XIOS").resume(); 
    369     if(!string_copy(fieldgroup_hdl->name.getInheritedValue(),name , name_size)) 
    370       ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    371      CTimer::get("XIOS").suspend(); 
    372   } 
    373    
    374   bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl ) 
    375   { 
    376      CTimer::get("XIOS").resume(); 
    377     return fieldgroup_hdl->name.hasInheritedValue(); 
    378      CTimer::get("XIOS").suspend(); 
    379   } 
    380    
    381    
    382    
     378    CTimer::get("XIOS").resume(); 
     379    if (!string_copy(fieldgroup_hdl->name.getInheritedValue(), name, name_size)) 
     380      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     381    CTimer::get("XIOS").suspend(); 
     382  } 
     383 
     384  bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl) 
     385  { 
     386     CTimer::get("XIOS").resume(); 
     387     bool isDefined = fieldgroup_hdl->name.hasInheritedValue(); 
     388     CTimer::get("XIOS").suspend(); 
     389     return isDefined; 
     390  } 
     391 
     392 
    383393  void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size) 
    384394  { 
    385395    std::string operation_str; 
    386     if(!cstr2string(operation, operation_size, operation_str)) return; 
    387      CTimer::get("XIOS").resume(); 
     396    if (!cstr2string(operation, operation_size, operation_str)) return; 
     397    CTimer::get("XIOS").resume(); 
    388398    fieldgroup_hdl->operation.setValue(operation_str); 
    389      CTimer::get("XIOS").suspend(); 
    390   } 
    391    
     399    CTimer::get("XIOS").suspend(); 
     400  } 
     401 
    392402  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size) 
    393403  { 
    394      CTimer::get("XIOS").resume(); 
    395     if(!string_copy(fieldgroup_hdl->operation.getInheritedValue(),operation , operation_size)) 
    396       ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
    397      CTimer::get("XIOS").suspend(); 
    398   } 
    399    
    400   bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl ) 
    401   { 
    402      CTimer::get("XIOS").resume(); 
    403     return fieldgroup_hdl->operation.hasInheritedValue(); 
    404      CTimer::get("XIOS").suspend(); 
    405   } 
    406    
    407    
    408    
     404    CTimer::get("XIOS").resume(); 
     405    if (!string_copy(fieldgroup_hdl->operation.getInheritedValue(), operation, operation_size)) 
     406      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", << "Input string is too short"); 
     407    CTimer::get("XIOS").suspend(); 
     408  } 
     409 
     410  bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl) 
     411  { 
     412     CTimer::get("XIOS").resume(); 
     413     bool isDefined = fieldgroup_hdl->operation.hasInheritedValue(); 
     414     CTimer::get("XIOS").suspend(); 
     415     return isDefined; 
     416  } 
     417 
     418 
    409419  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec) 
    410420  { 
    411      CTimer::get("XIOS").resume(); 
     421    CTimer::get("XIOS").resume(); 
    412422    fieldgroup_hdl->prec.setValue(prec); 
    413      CTimer::get("XIOS").suspend(); 
    414   } 
    415    
     423    CTimer::get("XIOS").suspend(); 
     424  } 
     425 
    416426  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec) 
    417427  { 
     428    CTimer::get("XIOS").resume(); 
    418429    *prec = fieldgroup_hdl->prec.getInheritedValue(); 
    419   } 
    420    
    421   bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl ) 
    422   { 
    423      CTimer::get("XIOS").resume(); 
    424     return fieldgroup_hdl->prec.hasInheritedValue(); 
    425      CTimer::get("XIOS").suspend(); 
    426   } 
    427    
    428    
    429    
     430    CTimer::get("XIOS").suspend(); 
     431  } 
     432 
     433  bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl) 
     434  { 
     435     CTimer::get("XIOS").resume(); 
     436     bool isDefined = fieldgroup_hdl->prec.hasInheritedValue(); 
     437     CTimer::get("XIOS").suspend(); 
     438     return isDefined; 
     439  } 
     440 
     441 
    430442  void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor) 
    431443  { 
    432      CTimer::get("XIOS").resume(); 
     444    CTimer::get("XIOS").resume(); 
    433445    fieldgroup_hdl->scale_factor.setValue(scale_factor); 
    434      CTimer::get("XIOS").suspend(); 
    435   } 
    436    
     446    CTimer::get("XIOS").suspend(); 
     447  } 
     448 
    437449  void cxios_get_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double* scale_factor) 
    438450  { 
     451    CTimer::get("XIOS").resume(); 
    439452    *scale_factor = fieldgroup_hdl->scale_factor.getInheritedValue(); 
    440   } 
    441    
    442   bool cxios_is_defined_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl ) 
    443   { 
    444      CTimer::get("XIOS").resume(); 
    445     return fieldgroup_hdl->scale_factor.hasInheritedValue(); 
    446      CTimer::get("XIOS").suspend(); 
    447   } 
    448    
    449    
    450    
     453    CTimer::get("XIOS").suspend(); 
     454  } 
     455 
     456  bool cxios_is_defined_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl) 
     457  { 
     458     CTimer::get("XIOS").resume(); 
     459     bool isDefined = fieldgroup_hdl->scale_factor.hasInheritedValue(); 
     460     CTimer::get("XIOS").suspend(); 
     461     return isDefined; 
     462  } 
     463 
     464 
    451465  void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size) 
    452466  { 
    453467    std::string standard_name_str; 
    454     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    455      CTimer::get("XIOS").resume(); 
     468    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     469    CTimer::get("XIOS").resume(); 
    456470    fieldgroup_hdl->standard_name.setValue(standard_name_str); 
    457      CTimer::get("XIOS").suspend(); 
    458   } 
    459    
     471    CTimer::get("XIOS").suspend(); 
     472  } 
     473 
    460474  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size) 
    461475  { 
    462      CTimer::get("XIOS").resume(); 
    463     if(!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    464       ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    465      CTimer::get("XIOS").suspend(); 
    466   } 
    467    
    468   bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl ) 
    469   { 
    470      CTimer::get("XIOS").resume(); 
    471     return fieldgroup_hdl->standard_name.hasInheritedValue(); 
    472      CTimer::get("XIOS").suspend(); 
    473   } 
    474    
    475    
    476    
     476    CTimer::get("XIOS").resume(); 
     477    if (!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     478      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     479    CTimer::get("XIOS").suspend(); 
     480  } 
     481 
     482  bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl) 
     483  { 
     484     CTimer::get("XIOS").resume(); 
     485     bool isDefined = fieldgroup_hdl->standard_name.hasInheritedValue(); 
     486     CTimer::get("XIOS").suspend(); 
     487     return isDefined; 
     488  } 
     489 
     490 
    477491  void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size) 
    478492  { 
    479493    std::string unit_str; 
    480     if(!cstr2string(unit, unit_size, unit_str)) return; 
    481      CTimer::get("XIOS").resume(); 
     494    if (!cstr2string(unit, unit_size, unit_str)) return; 
     495    CTimer::get("XIOS").resume(); 
    482496    fieldgroup_hdl->unit.setValue(unit_str); 
    483      CTimer::get("XIOS").suspend(); 
    484   } 
    485    
     497    CTimer::get("XIOS").suspend(); 
     498  } 
     499 
    486500  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size) 
    487501  { 
    488      CTimer::get("XIOS").resume(); 
    489     if(!string_copy(fieldgroup_hdl->unit.getInheritedValue(),unit , unit_size)) 
    490       ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    491      CTimer::get("XIOS").suspend(); 
    492   } 
    493    
    494   bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl ) 
    495   { 
    496      CTimer::get("XIOS").resume(); 
    497     return fieldgroup_hdl->unit.hasInheritedValue(); 
    498      CTimer::get("XIOS").suspend(); 
    499   } 
    500    
    501    
    502    
     502    CTimer::get("XIOS").resume(); 
     503    if (!string_copy(fieldgroup_hdl->unit.getInheritedValue(), unit, unit_size)) 
     504      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", << "Input string is too short"); 
     505    CTimer::get("XIOS").suspend(); 
     506  } 
     507 
     508  bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl) 
     509  { 
     510     CTimer::get("XIOS").resume(); 
     511     bool isDefined = fieldgroup_hdl->unit.hasInheritedValue(); 
     512     CTimer::get("XIOS").suspend(); 
     513     return isDefined; 
     514  } 
     515 
     516 
    503517  void cxios_set_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double valid_max) 
    504518  { 
    505      CTimer::get("XIOS").resume(); 
     519    CTimer::get("XIOS").resume(); 
    506520    fieldgroup_hdl->valid_max.setValue(valid_max); 
    507      CTimer::get("XIOS").suspend(); 
    508   } 
    509    
     521    CTimer::get("XIOS").suspend(); 
     522  } 
     523 
    510524  void cxios_get_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double* valid_max) 
    511525  { 
     526    CTimer::get("XIOS").resume(); 
    512527    *valid_max = fieldgroup_hdl->valid_max.getInheritedValue(); 
    513   } 
    514    
    515   bool cxios_is_defined_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl ) 
    516   { 
    517      CTimer::get("XIOS").resume(); 
    518     return fieldgroup_hdl->valid_max.hasInheritedValue(); 
    519      CTimer::get("XIOS").suspend(); 
    520   } 
    521    
    522    
    523    
     528    CTimer::get("XIOS").suspend(); 
     529  } 
     530 
     531  bool cxios_is_defined_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl) 
     532  { 
     533     CTimer::get("XIOS").resume(); 
     534     bool isDefined = fieldgroup_hdl->valid_max.hasInheritedValue(); 
     535     CTimer::get("XIOS").suspend(); 
     536     return isDefined; 
     537  } 
     538 
     539 
    524540  void cxios_set_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double valid_min) 
    525541  { 
    526      CTimer::get("XIOS").resume(); 
     542    CTimer::get("XIOS").resume(); 
    527543    fieldgroup_hdl->valid_min.setValue(valid_min); 
    528      CTimer::get("XIOS").suspend(); 
    529   } 
    530    
     544    CTimer::get("XIOS").suspend(); 
     545  } 
     546 
    531547  void cxios_get_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double* valid_min) 
    532548  { 
     549    CTimer::get("XIOS").resume(); 
    533550    *valid_min = fieldgroup_hdl->valid_min.getInheritedValue(); 
    534   } 
    535    
    536   bool cxios_is_defined_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl ) 
    537   { 
    538      CTimer::get("XIOS").resume(); 
    539     return fieldgroup_hdl->valid_min.hasInheritedValue(); 
    540      CTimer::get("XIOS").suspend(); 
    541   } 
    542    
    543    
    544    
    545    
     551    CTimer::get("XIOS").suspend(); 
     552  } 
     553 
     554  bool cxios_is_defined_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl) 
     555  { 
     556     CTimer::get("XIOS").resume(); 
     557     bool isDefined = fieldgroup_hdl->valid_min.hasInheritedValue(); 
     558     CTimer::get("XIOS").suspend(); 
     559     return isDefined; 
     560  } 
    546561} 
Note: See TracChangeset for help on using the changeset viewer.