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/icfield_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::CField*  field_Ptr; 
    19    
     18  typedef xios::CField* field_Ptr; 
     19 
    2020  void cxios_set_field_add_offset(field_Ptr field_hdl, double add_offset) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    field_hdl->add_offset.setValue(add_offset); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_field_add_offset(field_Ptr field_hdl, double* add_offset) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *add_offset = field_hdl->add_offset.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_field_add_offset(field_Ptr field_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return field_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_field_add_offset(field_Ptr field_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = field_hdl->add_offset.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_field_axis_ref(field_Ptr field_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    field_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_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size) 
    5153  { 
    52      CTimer::get("XIOS").resume(); 
    53     if(!string_copy(field_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    54       ERROR("void cxios_get_field_axis_ref(field_Ptr field_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_field_axis_ref(field_Ptr field_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return field_hdl->axis_ref.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(field_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size)) 
     56      ERROR("void cxios_get_field_axis_ref(field_Ptr field_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_field_axis_ref(field_Ptr field_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = field_hdl->axis_ref.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value) 
    6870  { 
    69      CTimer::get("XIOS").resume(); 
     71    CTimer::get("XIOS").resume(); 
    7072    field_hdl->default_value.setValue(default_value); 
    71      CTimer::get("XIOS").suspend(); 
    72   } 
    73    
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
    7476  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value) 
    7577  { 
     78    CTimer::get("XIOS").resume(); 
    7679    *default_value = field_hdl->default_value.getInheritedValue(); 
    77   } 
    78    
    79   bool cxios_is_defined_field_default_value(field_Ptr field_hdl ) 
    80   { 
    81      CTimer::get("XIOS").resume(); 
    82     return field_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_field_default_value(field_Ptr field_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = field_hdl->default_value.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
     90 
     91 
    8892  void cxios_set_field_detect_missing_value(field_Ptr field_hdl, bool detect_missing_value) 
    8993  { 
    90      CTimer::get("XIOS").resume(); 
     94    CTimer::get("XIOS").resume(); 
    9195    field_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_field_detect_missing_value(field_Ptr field_hdl, bool* detect_missing_value) 
    96100  { 
     101    CTimer::get("XIOS").resume(); 
    97102    *detect_missing_value = field_hdl->detect_missing_value.getInheritedValue(); 
    98   } 
    99    
    100   bool cxios_is_defined_field_detect_missing_value(field_Ptr field_hdl ) 
    101   { 
    102      CTimer::get("XIOS").resume(); 
    103     return field_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_field_detect_missing_value(field_Ptr field_hdl) 
     107  { 
     108     CTimer::get("XIOS").resume(); 
     109     bool isDefined = field_hdl->detect_missing_value.hasInheritedValue(); 
     110     CTimer::get("XIOS").suspend(); 
     111     return isDefined; 
     112  } 
     113 
     114 
    109115  void cxios_set_field_domain_ref(field_Ptr field_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    field_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_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size) 
    119125  { 
    120      CTimer::get("XIOS").resume(); 
    121     if(!string_copy(field_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    122       ERROR("void cxios_get_field_domain_ref(field_Ptr field_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_field_domain_ref(field_Ptr field_hdl ) 
    127   { 
    128      CTimer::get("XIOS").resume(); 
    129     return field_hdl->domain_ref.hasInheritedValue(); 
    130      CTimer::get("XIOS").suspend(); 
    131   } 
    132    
    133    
    134    
     126    CTimer::get("XIOS").resume(); 
     127    if (!string_copy(field_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size)) 
     128      ERROR("void cxios_get_field_domain_ref(field_Ptr field_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_field_domain_ref(field_Ptr field_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = field_hdl->domain_ref.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    135141  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled) 
    136142  { 
    137      CTimer::get("XIOS").resume(); 
     143    CTimer::get("XIOS").resume(); 
    138144    field_hdl->enabled.setValue(enabled); 
    139      CTimer::get("XIOS").suspend(); 
    140   } 
    141    
     145    CTimer::get("XIOS").suspend(); 
     146  } 
     147 
    142148  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled) 
    143149  { 
     150    CTimer::get("XIOS").resume(); 
    144151    *enabled = field_hdl->enabled.getInheritedValue(); 
    145   } 
    146    
    147   bool cxios_is_defined_field_enabled(field_Ptr field_hdl ) 
    148   { 
    149      CTimer::get("XIOS").resume(); 
    150     return field_hdl->enabled.hasInheritedValue(); 
    151      CTimer::get("XIOS").suspend(); 
    152   } 
    153    
    154    
    155    
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  bool cxios_is_defined_field_enabled(field_Ptr field_hdl) 
     156  { 
     157     CTimer::get("XIOS").resume(); 
     158     bool isDefined = field_hdl->enabled.hasInheritedValue(); 
     159     CTimer::get("XIOS").suspend(); 
     160     return isDefined; 
     161  } 
     162 
     163 
    156164  void cxios_set_field_field_ref(field_Ptr field_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    field_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_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size) 
    166174  { 
    167      CTimer::get("XIOS").resume(); 
    168     if(!string_copy(field_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size)) 
    169       ERROR("void cxios_get_field_field_ref(field_Ptr field_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_field_field_ref(field_Ptr field_hdl ) 
    174   { 
    175      CTimer::get("XIOS").resume(); 
    176     return field_hdl->field_ref.hasInheritedValue(); 
    177      CTimer::get("XIOS").suspend(); 
    178   } 
    179    
    180    
    181    
     175    CTimer::get("XIOS").resume(); 
     176    if (!string_copy(field_hdl->field_ref.getInheritedValue(), field_ref, field_ref_size)) 
     177      ERROR("void cxios_get_field_field_ref(field_Ptr field_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_field_field_ref(field_Ptr field_hdl) 
     182  { 
     183     CTimer::get("XIOS").resume(); 
     184     bool isDefined = field_hdl->field_ref.hasInheritedValue(); 
     185     CTimer::get("XIOS").suspend(); 
     186     return isDefined; 
     187  } 
     188 
     189 
    182190  void cxios_set_field_freq_offset(field_Ptr field_hdl, cxios_duration freq_offset_c) 
    183191  { 
    … …  
    194202    CTimer::get("XIOS").suspend(); 
    195203  } 
    196    
     204 
    197205  void cxios_get_field_freq_offset(field_Ptr field_hdl, cxios_duration* freq_offset_c) 
    198206  { 
    … …  
    208216    CTimer::get("XIOS").suspend(); 
    209217  } 
    210    
    211   bool cxios_is_defined_field_freq_offset(field_Ptr field_hdl ) 
    212   { 
    213      CTimer::get("XIOS").resume(); 
    214     return field_hdl->freq_offset.hasInheritedValue(); 
    215      CTimer::get("XIOS").suspend(); 
    216   } 
    217    
    218    
    219    
     218 
     219  bool cxios_is_defined_field_freq_offset(field_Ptr field_hdl) 
     220  { 
     221     CTimer::get("XIOS").resume(); 
     222     bool isDefined = field_hdl->freq_offset.hasInheritedValue(); 
     223     CTimer::get("XIOS").suspend(); 
     224     return isDefined; 
     225  } 
     226 
     227 
    220228  void cxios_set_field_freq_op(field_Ptr field_hdl, cxios_duration freq_op_c) 
    221229  { 
    … …  
    232240    CTimer::get("XIOS").suspend(); 
    233241  } 
    234    
     242 
    235243  void cxios_get_field_freq_op(field_Ptr field_hdl, cxios_duration* freq_op_c) 
    236244  { 
    … …  
    246254    CTimer::get("XIOS").suspend(); 
    247255  } 
    248    
    249   bool cxios_is_defined_field_freq_op(field_Ptr field_hdl ) 
    250   { 
    251      CTimer::get("XIOS").resume(); 
    252     return field_hdl->freq_op.hasInheritedValue(); 
    253      CTimer::get("XIOS").suspend(); 
    254   } 
    255    
    256    
    257    
     256 
     257  bool cxios_is_defined_field_freq_op(field_Ptr field_hdl) 
     258  { 
     259     CTimer::get("XIOS").resume(); 
     260     bool isDefined = field_hdl->freq_op.hasInheritedValue(); 
     261     CTimer::get("XIOS").suspend(); 
     262     return isDefined; 
     263  } 
     264 
     265 
    258266  void cxios_set_field_grid_ref(field_Ptr field_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    field_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_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size) 
    268276  { 
    269      CTimer::get("XIOS").resume(); 
    270     if(!string_copy(field_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size)) 
    271       ERROR("void cxios_get_field_grid_ref(field_Ptr field_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_field_grid_ref(field_Ptr field_hdl ) 
    276   { 
    277      CTimer::get("XIOS").resume(); 
    278     return field_hdl->grid_ref.hasInheritedValue(); 
    279      CTimer::get("XIOS").suspend(); 
    280   } 
    281    
    282    
    283    
     277    CTimer::get("XIOS").resume(); 
     278    if (!string_copy(field_hdl->grid_ref.getInheritedValue(), grid_ref, grid_ref_size)) 
     279      ERROR("void cxios_get_field_grid_ref(field_Ptr field_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_field_grid_ref(field_Ptr field_hdl) 
     284  { 
     285     CTimer::get("XIOS").resume(); 
     286     bool isDefined = field_hdl->grid_ref.hasInheritedValue(); 
     287     CTimer::get("XIOS").suspend(); 
     288     return isDefined; 
     289  } 
     290 
     291 
    284292  void cxios_set_field_level(field_Ptr field_hdl, int level) 
    285293  { 
    286      CTimer::get("XIOS").resume(); 
     294    CTimer::get("XIOS").resume(); 
    287295    field_hdl->level.setValue(level); 
    288      CTimer::get("XIOS").suspend(); 
    289   } 
    290    
     296    CTimer::get("XIOS").suspend(); 
     297  } 
     298 
    291299  void cxios_get_field_level(field_Ptr field_hdl, int* level) 
    292300  { 
     301    CTimer::get("XIOS").resume(); 
    293302    *level = field_hdl->level.getInheritedValue(); 
    294   } 
    295    
    296   bool cxios_is_defined_field_level(field_Ptr field_hdl ) 
    297   { 
    298      CTimer::get("XIOS").resume(); 
    299     return field_hdl->level.hasInheritedValue(); 
    300      CTimer::get("XIOS").suspend(); 
    301   } 
    302    
    303    
    304    
     303    CTimer::get("XIOS").suspend(); 
     304  } 
     305 
     306  bool cxios_is_defined_field_level(field_Ptr field_hdl) 
     307  { 
     308     CTimer::get("XIOS").resume(); 
     309     bool isDefined = field_hdl->level.hasInheritedValue(); 
     310     CTimer::get("XIOS").suspend(); 
     311     return isDefined; 
     312  } 
     313 
     314 
    305315  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size) 
    306316  { 
    307317    std::string long_name_str; 
    308     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    309      CTimer::get("XIOS").resume(); 
     318    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     319    CTimer::get("XIOS").resume(); 
    310320    field_hdl->long_name.setValue(long_name_str); 
    311      CTimer::get("XIOS").suspend(); 
    312   } 
    313    
     321    CTimer::get("XIOS").suspend(); 
     322  } 
     323 
    314324  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size) 
    315325  { 
    316      CTimer::get("XIOS").resume(); 
    317     if(!string_copy(field_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    318       ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    319      CTimer::get("XIOS").suspend(); 
    320   } 
    321    
    322   bool cxios_is_defined_field_long_name(field_Ptr field_hdl ) 
    323   { 
    324      CTimer::get("XIOS").resume(); 
    325     return field_hdl->long_name.hasInheritedValue(); 
    326      CTimer::get("XIOS").suspend(); 
    327   } 
    328    
    329    
    330    
     326    CTimer::get("XIOS").resume(); 
     327    if (!string_copy(field_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     328      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     329    CTimer::get("XIOS").suspend(); 
     330  } 
     331 
     332  bool cxios_is_defined_field_long_name(field_Ptr field_hdl) 
     333  { 
     334     CTimer::get("XIOS").resume(); 
     335     bool isDefined = field_hdl->long_name.hasInheritedValue(); 
     336     CTimer::get("XIOS").suspend(); 
     337     return isDefined; 
     338  } 
     339 
     340 
    331341  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size) 
    332342  { 
    333343    std::string name_str; 
    334     if(!cstr2string(name, name_size, name_str)) return; 
    335      CTimer::get("XIOS").resume(); 
     344    if (!cstr2string(name, name_size, name_str)) return; 
     345    CTimer::get("XIOS").resume(); 
    336346    field_hdl->name.setValue(name_str); 
    337      CTimer::get("XIOS").suspend(); 
    338   } 
    339    
     347    CTimer::get("XIOS").suspend(); 
     348  } 
     349 
    340350  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size) 
    341351  { 
    342      CTimer::get("XIOS").resume(); 
    343     if(!string_copy(field_hdl->name.getInheritedValue(),name , name_size)) 
    344       ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short"); 
    345      CTimer::get("XIOS").suspend(); 
    346   } 
    347    
    348   bool cxios_is_defined_field_name(field_Ptr field_hdl ) 
    349   { 
    350      CTimer::get("XIOS").resume(); 
    351     return field_hdl->name.hasInheritedValue(); 
    352      CTimer::get("XIOS").suspend(); 
    353   } 
    354    
    355    
    356    
     352    CTimer::get("XIOS").resume(); 
     353    if (!string_copy(field_hdl->name.getInheritedValue(), name, name_size)) 
     354      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", << "Input string is too short"); 
     355    CTimer::get("XIOS").suspend(); 
     356  } 
     357 
     358  bool cxios_is_defined_field_name(field_Ptr field_hdl) 
     359  { 
     360     CTimer::get("XIOS").resume(); 
     361     bool isDefined = field_hdl->name.hasInheritedValue(); 
     362     CTimer::get("XIOS").suspend(); 
     363     return isDefined; 
     364  } 
     365 
     366 
    357367  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size) 
    358368  { 
    359369    std::string operation_str; 
    360     if(!cstr2string(operation, operation_size, operation_str)) return; 
    361      CTimer::get("XIOS").resume(); 
     370    if (!cstr2string(operation, operation_size, operation_str)) return; 
     371    CTimer::get("XIOS").resume(); 
    362372    field_hdl->operation.setValue(operation_str); 
    363      CTimer::get("XIOS").suspend(); 
    364   } 
    365    
     373    CTimer::get("XIOS").suspend(); 
     374  } 
     375 
    366376  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size) 
    367377  { 
    368      CTimer::get("XIOS").resume(); 
    369     if(!string_copy(field_hdl->operation.getInheritedValue(),operation , operation_size)) 
    370       ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
    371      CTimer::get("XIOS").suspend(); 
    372   } 
    373    
    374   bool cxios_is_defined_field_operation(field_Ptr field_hdl ) 
    375   { 
    376      CTimer::get("XIOS").resume(); 
    377     return field_hdl->operation.hasInheritedValue(); 
    378      CTimer::get("XIOS").suspend(); 
    379   } 
    380    
    381    
    382    
     378    CTimer::get("XIOS").resume(); 
     379    if (!string_copy(field_hdl->operation.getInheritedValue(), operation, operation_size)) 
     380      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", << "Input string is too short"); 
     381    CTimer::get("XIOS").suspend(); 
     382  } 
     383 
     384  bool cxios_is_defined_field_operation(field_Ptr field_hdl) 
     385  { 
     386     CTimer::get("XIOS").resume(); 
     387     bool isDefined = field_hdl->operation.hasInheritedValue(); 
     388     CTimer::get("XIOS").suspend(); 
     389     return isDefined; 
     390  } 
     391 
     392 
    383393  void cxios_set_field_prec(field_Ptr field_hdl, int prec) 
    384394  { 
    385      CTimer::get("XIOS").resume(); 
     395    CTimer::get("XIOS").resume(); 
    386396    field_hdl->prec.setValue(prec); 
    387      CTimer::get("XIOS").suspend(); 
    388   } 
    389    
     397    CTimer::get("XIOS").suspend(); 
     398  } 
     399 
    390400  void cxios_get_field_prec(field_Ptr field_hdl, int* prec) 
    391401  { 
     402    CTimer::get("XIOS").resume(); 
    392403    *prec = field_hdl->prec.getInheritedValue(); 
    393   } 
    394    
    395   bool cxios_is_defined_field_prec(field_Ptr field_hdl ) 
    396   { 
    397      CTimer::get("XIOS").resume(); 
    398     return field_hdl->prec.hasInheritedValue(); 
    399      CTimer::get("XIOS").suspend(); 
    400   } 
    401    
    402    
    403    
     404    CTimer::get("XIOS").suspend(); 
     405  } 
     406 
     407  bool cxios_is_defined_field_prec(field_Ptr field_hdl) 
     408  { 
     409     CTimer::get("XIOS").resume(); 
     410     bool isDefined = field_hdl->prec.hasInheritedValue(); 
     411     CTimer::get("XIOS").suspend(); 
     412     return isDefined; 
     413  } 
     414 
     415 
    404416  void cxios_set_field_scale_factor(field_Ptr field_hdl, double scale_factor) 
    405417  { 
    406      CTimer::get("XIOS").resume(); 
     418    CTimer::get("XIOS").resume(); 
    407419    field_hdl->scale_factor.setValue(scale_factor); 
    408      CTimer::get("XIOS").suspend(); 
    409   } 
    410    
     420    CTimer::get("XIOS").suspend(); 
     421  } 
     422 
    411423  void cxios_get_field_scale_factor(field_Ptr field_hdl, double* scale_factor) 
    412424  { 
     425    CTimer::get("XIOS").resume(); 
    413426    *scale_factor = field_hdl->scale_factor.getInheritedValue(); 
    414   } 
    415    
    416   bool cxios_is_defined_field_scale_factor(field_Ptr field_hdl ) 
    417   { 
    418      CTimer::get("XIOS").resume(); 
    419     return field_hdl->scale_factor.hasInheritedValue(); 
    420      CTimer::get("XIOS").suspend(); 
    421   } 
    422    
    423    
    424    
     427    CTimer::get("XIOS").suspend(); 
     428  } 
     429 
     430  bool cxios_is_defined_field_scale_factor(field_Ptr field_hdl) 
     431  { 
     432     CTimer::get("XIOS").resume(); 
     433     bool isDefined = field_hdl->scale_factor.hasInheritedValue(); 
     434     CTimer::get("XIOS").suspend(); 
     435     return isDefined; 
     436  } 
     437 
     438 
    425439  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size) 
    426440  { 
    427441    std::string standard_name_str; 
    428     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    429      CTimer::get("XIOS").resume(); 
     442    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     443    CTimer::get("XIOS").resume(); 
    430444    field_hdl->standard_name.setValue(standard_name_str); 
    431      CTimer::get("XIOS").suspend(); 
    432   } 
    433    
     445    CTimer::get("XIOS").suspend(); 
     446  } 
     447 
    434448  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size) 
    435449  { 
    436      CTimer::get("XIOS").resume(); 
    437     if(!string_copy(field_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    438       ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    439      CTimer::get("XIOS").suspend(); 
    440   } 
    441    
    442   bool cxios_is_defined_field_standard_name(field_Ptr field_hdl ) 
    443   { 
    444      CTimer::get("XIOS").resume(); 
    445     return field_hdl->standard_name.hasInheritedValue(); 
    446      CTimer::get("XIOS").suspend(); 
    447   } 
    448    
    449    
    450    
     450    CTimer::get("XIOS").resume(); 
     451    if (!string_copy(field_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     452      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     453    CTimer::get("XIOS").suspend(); 
     454  } 
     455 
     456  bool cxios_is_defined_field_standard_name(field_Ptr field_hdl) 
     457  { 
     458     CTimer::get("XIOS").resume(); 
     459     bool isDefined = field_hdl->standard_name.hasInheritedValue(); 
     460     CTimer::get("XIOS").suspend(); 
     461     return isDefined; 
     462  } 
     463 
     464 
    451465  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size) 
    452466  { 
    453467    std::string unit_str; 
    454     if(!cstr2string(unit, unit_size, unit_str)) return; 
    455      CTimer::get("XIOS").resume(); 
     468    if (!cstr2string(unit, unit_size, unit_str)) return; 
     469    CTimer::get("XIOS").resume(); 
    456470    field_hdl->unit.setValue(unit_str); 
    457      CTimer::get("XIOS").suspend(); 
    458   } 
    459    
     471    CTimer::get("XIOS").suspend(); 
     472  } 
     473 
    460474  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size) 
    461475  { 
    462      CTimer::get("XIOS").resume(); 
    463     if(!string_copy(field_hdl->unit.getInheritedValue(),unit , unit_size)) 
    464       ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    465      CTimer::get("XIOS").suspend(); 
    466   } 
    467    
    468   bool cxios_is_defined_field_unit(field_Ptr field_hdl ) 
    469   { 
    470      CTimer::get("XIOS").resume(); 
    471     return field_hdl->unit.hasInheritedValue(); 
    472      CTimer::get("XIOS").suspend(); 
    473   } 
    474    
    475    
    476    
     476    CTimer::get("XIOS").resume(); 
     477    if (!string_copy(field_hdl->unit.getInheritedValue(), unit, unit_size)) 
     478      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", << "Input string is too short"); 
     479    CTimer::get("XIOS").suspend(); 
     480  } 
     481 
     482  bool cxios_is_defined_field_unit(field_Ptr field_hdl) 
     483  { 
     484     CTimer::get("XIOS").resume(); 
     485     bool isDefined = field_hdl->unit.hasInheritedValue(); 
     486     CTimer::get("XIOS").suspend(); 
     487     return isDefined; 
     488  } 
     489 
     490 
    477491  void cxios_set_field_valid_max(field_Ptr field_hdl, double valid_max) 
    478492  { 
    479      CTimer::get("XIOS").resume(); 
     493    CTimer::get("XIOS").resume(); 
    480494    field_hdl->valid_max.setValue(valid_max); 
    481      CTimer::get("XIOS").suspend(); 
    482   } 
    483    
     495    CTimer::get("XIOS").suspend(); 
     496  } 
     497 
    484498  void cxios_get_field_valid_max(field_Ptr field_hdl, double* valid_max) 
    485499  { 
     500    CTimer::get("XIOS").resume(); 
    486501    *valid_max = field_hdl->valid_max.getInheritedValue(); 
    487   } 
    488    
    489   bool cxios_is_defined_field_valid_max(field_Ptr field_hdl ) 
    490   { 
    491      CTimer::get("XIOS").resume(); 
    492     return field_hdl->valid_max.hasInheritedValue(); 
    493      CTimer::get("XIOS").suspend(); 
    494   } 
    495    
    496    
    497    
     502    CTimer::get("XIOS").suspend(); 
     503  } 
     504 
     505  bool cxios_is_defined_field_valid_max(field_Ptr field_hdl) 
     506  { 
     507     CTimer::get("XIOS").resume(); 
     508     bool isDefined = field_hdl->valid_max.hasInheritedValue(); 
     509     CTimer::get("XIOS").suspend(); 
     510     return isDefined; 
     511  } 
     512 
     513 
    498514  void cxios_set_field_valid_min(field_Ptr field_hdl, double valid_min) 
    499515  { 
    500      CTimer::get("XIOS").resume(); 
     516    CTimer::get("XIOS").resume(); 
    501517    field_hdl->valid_min.setValue(valid_min); 
    502      CTimer::get("XIOS").suspend(); 
    503   } 
    504    
     518    CTimer::get("XIOS").suspend(); 
     519  } 
     520 
    505521  void cxios_get_field_valid_min(field_Ptr field_hdl, double* valid_min) 
    506522  { 
     523    CTimer::get("XIOS").resume(); 
    507524    *valid_min = field_hdl->valid_min.getInheritedValue(); 
    508   } 
    509    
    510   bool cxios_is_defined_field_valid_min(field_Ptr field_hdl ) 
    511   { 
    512      CTimer::get("XIOS").resume(); 
    513     return field_hdl->valid_min.hasInheritedValue(); 
    514      CTimer::get("XIOS").suspend(); 
    515   } 
    516    
    517    
    518    
    519    
     525    CTimer::get("XIOS").suspend(); 
     526  } 
     527 
     528  bool cxios_is_defined_field_valid_min(field_Ptr field_hdl) 
     529  { 
     530     CTimer::get("XIOS").resume(); 
     531     bool isDefined = field_hdl->valid_min.hasInheritedValue(); 
     532     CTimer::get("XIOS").suspend(); 
     533     return isDefined; 
     534  } 
    520535} 
Note: See TracChangeset for help on using the changeset viewer.