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.

Location:
XIOS/trunk/src/interface/c_attr
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r555 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CAxis*  axis_Ptr; 
    19    
     18  typedef xios::CAxis* axis_Ptr; 
     19 
    2020  void cxios_set_axis_axis_ref(axis_Ptr axis_hdl, const char * axis_ref, int axis_ref_size) 
    2121  { 
    2222    std::string axis_ref_str; 
    23     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    24      CTimer::get("XIOS").resume(); 
     23    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     24    CTimer::get("XIOS").resume(); 
    2525    axis_hdl->axis_ref.setValue(axis_ref_str); 
    26      CTimer::get("XIOS").suspend(); 
    27   } 
    28    
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
    2929  void cxios_get_axis_axis_ref(axis_Ptr axis_hdl, char * axis_ref, int axis_ref_size) 
    3030  { 
    31      CTimer::get("XIOS").resume(); 
    32     if(!string_copy(axis_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    33       ERROR("void cxios_get_axis_axis_ref(axis_Ptr axis_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    34      CTimer::get("XIOS").suspend(); 
    35   } 
    36    
    37   bool cxios_is_defined_axis_axis_ref(axis_Ptr axis_hdl ) 
    38   { 
    39      CTimer::get("XIOS").resume(); 
    40     return axis_hdl->axis_ref.hasInheritedValue(); 
    41      CTimer::get("XIOS").suspend(); 
    42   } 
    43    
    44    
    45    
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(axis_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size)) 
     33      ERROR("void cxios_get_axis_axis_ref(axis_Ptr axis_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_axis_axis_ref(axis_Ptr axis_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = axis_hdl->axis_ref.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    4646  void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin) 
    4747  { 
    48      CTimer::get("XIOS").resume(); 
     48    CTimer::get("XIOS").resume(); 
    4949    axis_hdl->data_begin.setValue(data_begin); 
    50      CTimer::get("XIOS").suspend(); 
    51   } 
    52    
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
    5353  void cxios_get_axis_data_begin(axis_Ptr axis_hdl, int* data_begin) 
    5454  { 
     55    CTimer::get("XIOS").resume(); 
    5556    *data_begin = axis_hdl->data_begin.getInheritedValue(); 
    56   } 
    57    
    58   bool cxios_is_defined_axis_data_begin(axis_Ptr axis_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return axis_hdl->data_begin.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_axis_data_begin(axis_Ptr axis_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = axis_hdl->data_begin.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_axis_data_index(axis_Ptr axis_hdl, int* data_index, int extent1) 
    6870  { 
    6971    CTimer::get("XIOS").resume(); 
    70     CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ; 
     72    CArray<int,1> tmp(data_index, shape(extent1), neverDeleteData); 
    7173    axis_hdl->data_index.reference(tmp.copy()); 
    7274     CTimer::get("XIOS").suspend(); 
    7375  } 
    74    
     76 
    7577  void cxios_get_axis_data_index(axis_Ptr axis_hdl, int* data_index, int extent1) 
    7678  { 
    7779    CTimer::get("XIOS").resume(); 
    78     CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ; 
    79     tmp=axis_hdl->data_index.getInheritedValue() ; 
    80      CTimer::get("XIOS").suspend(); 
    81   } 
    82    
    83   bool cxios_is_defined_axis_data_index(axis_Ptr axis_hdl ) 
    84   { 
    85      CTimer::get("XIOS").resume(); 
    86     return axis_hdl->data_index.hasInheritedValue(); 
    87      CTimer::get("XIOS").suspend(); 
    88   } 
    89    
    90    
    91    
     80    CArray<int,1> tmp(data_index, shape(extent1), neverDeleteData); 
     81    tmp=axis_hdl->data_index.getInheritedValue(); 
     82     CTimer::get("XIOS").suspend(); 
     83  } 
     84 
     85  bool cxios_is_defined_axis_data_index(axis_Ptr axis_hdl) 
     86  { 
     87     CTimer::get("XIOS").resume(); 
     88     bool isDefined = axis_hdl->data_index.hasInheritedValue(); 
     89     CTimer::get("XIOS").suspend(); 
     90     return isDefined; 
     91  } 
     92 
     93 
    9294  void cxios_set_axis_data_n(axis_Ptr axis_hdl, int data_n) 
    9395  { 
    94      CTimer::get("XIOS").resume(); 
     96    CTimer::get("XIOS").resume(); 
    9597    axis_hdl->data_n.setValue(data_n); 
    96      CTimer::get("XIOS").suspend(); 
    97   } 
    98    
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
    99101  void cxios_get_axis_data_n(axis_Ptr axis_hdl, int* data_n) 
    100102  { 
     103    CTimer::get("XIOS").resume(); 
    101104    *data_n = axis_hdl->data_n.getInheritedValue(); 
    102   } 
    103    
    104   bool cxios_is_defined_axis_data_n(axis_Ptr axis_hdl ) 
    105   { 
    106      CTimer::get("XIOS").resume(); 
    107     return axis_hdl->data_n.hasInheritedValue(); 
    108      CTimer::get("XIOS").suspend(); 
    109   } 
    110    
    111    
    112    
     105    CTimer::get("XIOS").suspend(); 
     106  } 
     107 
     108  bool cxios_is_defined_axis_data_n(axis_Ptr axis_hdl) 
     109  { 
     110     CTimer::get("XIOS").resume(); 
     111     bool isDefined = axis_hdl->data_n.hasInheritedValue(); 
     112     CTimer::get("XIOS").suspend(); 
     113     return isDefined; 
     114  } 
     115 
     116 
    113117  void cxios_set_axis_ibegin(axis_Ptr axis_hdl, int ibegin) 
    114118  { 
    115      CTimer::get("XIOS").resume(); 
     119    CTimer::get("XIOS").resume(); 
    116120    axis_hdl->ibegin.setValue(ibegin); 
    117      CTimer::get("XIOS").suspend(); 
    118   } 
    119    
     121    CTimer::get("XIOS").suspend(); 
     122  } 
     123 
    120124  void cxios_get_axis_ibegin(axis_Ptr axis_hdl, int* ibegin) 
    121125  { 
     126    CTimer::get("XIOS").resume(); 
    122127    *ibegin = axis_hdl->ibegin.getInheritedValue(); 
    123   } 
    124    
    125   bool cxios_is_defined_axis_ibegin(axis_Ptr axis_hdl ) 
    126   { 
    127      CTimer::get("XIOS").resume(); 
    128     return axis_hdl->ibegin.hasInheritedValue(); 
    129      CTimer::get("XIOS").suspend(); 
    130   } 
    131    
    132    
    133    
     128    CTimer::get("XIOS").suspend(); 
     129  } 
     130 
     131  bool cxios_is_defined_axis_ibegin(axis_Ptr axis_hdl) 
     132  { 
     133     CTimer::get("XIOS").resume(); 
     134     bool isDefined = axis_hdl->ibegin.hasInheritedValue(); 
     135     CTimer::get("XIOS").suspend(); 
     136     return isDefined; 
     137  } 
     138 
     139 
    134140  void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size) 
    135141  { 
    136142    std::string long_name_str; 
    137     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    138      CTimer::get("XIOS").resume(); 
     143    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     144    CTimer::get("XIOS").resume(); 
    139145    axis_hdl->long_name.setValue(long_name_str); 
    140      CTimer::get("XIOS").suspend(); 
    141   } 
    142    
     146    CTimer::get("XIOS").suspend(); 
     147  } 
     148 
    143149  void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size) 
    144150  { 
    145      CTimer::get("XIOS").resume(); 
    146     if(!string_copy(axis_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    147       ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    148      CTimer::get("XIOS").suspend(); 
    149   } 
    150    
    151   bool cxios_is_defined_axis_long_name(axis_Ptr axis_hdl ) 
    152   { 
    153      CTimer::get("XIOS").resume(); 
    154     return axis_hdl->long_name.hasInheritedValue(); 
    155      CTimer::get("XIOS").suspend(); 
    156   } 
    157    
    158    
    159    
     151    CTimer::get("XIOS").resume(); 
     152    if (!string_copy(axis_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     153      ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     154    CTimer::get("XIOS").suspend(); 
     155  } 
     156 
     157  bool cxios_is_defined_axis_long_name(axis_Ptr axis_hdl) 
     158  { 
     159     CTimer::get("XIOS").resume(); 
     160     bool isDefined = axis_hdl->long_name.hasInheritedValue(); 
     161     CTimer::get("XIOS").suspend(); 
     162     return isDefined; 
     163  } 
     164 
     165 
    160166  void cxios_set_axis_mask(axis_Ptr axis_hdl, bool* mask, int extent1) 
    161167  { 
    162168    CTimer::get("XIOS").resume(); 
    163     CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ; 
     169    CArray<bool,1> tmp(mask, shape(extent1), neverDeleteData); 
    164170    axis_hdl->mask.reference(tmp.copy()); 
    165171     CTimer::get("XIOS").suspend(); 
    166172  } 
    167    
     173 
    168174  void cxios_get_axis_mask(axis_Ptr axis_hdl, bool* mask, int extent1) 
    169175  { 
    170176    CTimer::get("XIOS").resume(); 
    171     CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ; 
    172     tmp=axis_hdl->mask.getInheritedValue() ; 
    173      CTimer::get("XIOS").suspend(); 
    174   } 
    175    
    176   bool cxios_is_defined_axis_mask(axis_Ptr axis_hdl ) 
    177   { 
    178      CTimer::get("XIOS").resume(); 
    179     return axis_hdl->mask.hasInheritedValue(); 
    180      CTimer::get("XIOS").suspend(); 
    181   } 
    182    
    183    
    184    
     177    CArray<bool,1> tmp(mask, shape(extent1), neverDeleteData); 
     178    tmp=axis_hdl->mask.getInheritedValue(); 
     179     CTimer::get("XIOS").suspend(); 
     180  } 
     181 
     182  bool cxios_is_defined_axis_mask(axis_Ptr axis_hdl) 
     183  { 
     184     CTimer::get("XIOS").resume(); 
     185     bool isDefined = axis_hdl->mask.hasInheritedValue(); 
     186     CTimer::get("XIOS").suspend(); 
     187     return isDefined; 
     188  } 
     189 
     190 
    185191  void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size) 
    186192  { 
    187193    std::string name_str; 
    188     if(!cstr2string(name, name_size, name_str)) return; 
    189      CTimer::get("XIOS").resume(); 
     194    if (!cstr2string(name, name_size, name_str)) return; 
     195    CTimer::get("XIOS").resume(); 
    190196    axis_hdl->name.setValue(name_str); 
    191      CTimer::get("XIOS").suspend(); 
    192   } 
    193    
     197    CTimer::get("XIOS").suspend(); 
     198  } 
     199 
    194200  void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size) 
    195201  { 
    196      CTimer::get("XIOS").resume(); 
    197     if(!string_copy(axis_hdl->name.getInheritedValue(),name , name_size)) 
    198       ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", <<"Input string is to short"); 
    199      CTimer::get("XIOS").suspend(); 
    200   } 
    201    
    202   bool cxios_is_defined_axis_name(axis_Ptr axis_hdl ) 
    203   { 
    204      CTimer::get("XIOS").resume(); 
    205     return axis_hdl->name.hasInheritedValue(); 
    206      CTimer::get("XIOS").suspend(); 
    207   } 
    208    
    209    
    210    
     202    CTimer::get("XIOS").resume(); 
     203    if (!string_copy(axis_hdl->name.getInheritedValue(), name, name_size)) 
     204      ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", << "Input string is too short"); 
     205    CTimer::get("XIOS").suspend(); 
     206  } 
     207 
     208  bool cxios_is_defined_axis_name(axis_Ptr axis_hdl) 
     209  { 
     210     CTimer::get("XIOS").resume(); 
     211     bool isDefined = axis_hdl->name.hasInheritedValue(); 
     212     CTimer::get("XIOS").suspend(); 
     213     return isDefined; 
     214  } 
     215 
     216 
    211217  void cxios_set_axis_ni(axis_Ptr axis_hdl, int ni) 
    212218  { 
    213      CTimer::get("XIOS").resume(); 
     219    CTimer::get("XIOS").resume(); 
    214220    axis_hdl->ni.setValue(ni); 
    215      CTimer::get("XIOS").suspend(); 
    216   } 
    217    
     221    CTimer::get("XIOS").suspend(); 
     222  } 
     223 
    218224  void cxios_get_axis_ni(axis_Ptr axis_hdl, int* ni) 
    219225  { 
     226    CTimer::get("XIOS").resume(); 
    220227    *ni = axis_hdl->ni.getInheritedValue(); 
    221   } 
    222    
    223   bool cxios_is_defined_axis_ni(axis_Ptr axis_hdl ) 
    224   { 
    225      CTimer::get("XIOS").resume(); 
    226     return axis_hdl->ni.hasInheritedValue(); 
    227      CTimer::get("XIOS").suspend(); 
    228   } 
    229    
    230    
    231    
     228    CTimer::get("XIOS").suspend(); 
     229  } 
     230 
     231  bool cxios_is_defined_axis_ni(axis_Ptr axis_hdl) 
     232  { 
     233     CTimer::get("XIOS").resume(); 
     234     bool isDefined = axis_hdl->ni.hasInheritedValue(); 
     235     CTimer::get("XIOS").suspend(); 
     236     return isDefined; 
     237  } 
     238 
     239 
    232240  void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size) 
    233241  { 
    234242    std::string positive_str; 
    235     if(!cstr2string(positive, positive_size, positive_str)) return; 
    236      CTimer::get("XIOS").resume(); 
     243    if (!cstr2string(positive, positive_size, positive_str)) return; 
     244    CTimer::get("XIOS").resume(); 
    237245    axis_hdl->positive.fromString(positive_str); 
    238      CTimer::get("XIOS").suspend(); 
    239   } 
    240    
     246    CTimer::get("XIOS").suspend(); 
     247  } 
     248 
    241249  void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size) 
    242250  { 
    243      CTimer::get("XIOS").resume(); 
    244     if(!string_copy(axis_hdl->positive.getInheritedStringValue(),positive , positive_size)) 
    245       ERROR("void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)", <<"Input string is to short"); 
    246      CTimer::get("XIOS").suspend(); 
    247   } 
    248    
    249   bool cxios_is_defined_axis_positive(axis_Ptr axis_hdl ) 
    250   { 
    251      CTimer::get("XIOS").resume(); 
    252     return axis_hdl->positive.hasInheritedValue(); 
    253      CTimer::get("XIOS").suspend(); 
    254   } 
    255    
    256    
    257    
     251    CTimer::get("XIOS").resume(); 
     252    if (!string_copy(axis_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     253      ERROR("void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     254    CTimer::get("XIOS").suspend(); 
     255  } 
     256 
     257  bool cxios_is_defined_axis_positive(axis_Ptr axis_hdl) 
     258  { 
     259     CTimer::get("XIOS").resume(); 
     260     bool isDefined = axis_hdl->positive.hasInheritedValue(); 
     261     CTimer::get("XIOS").suspend(); 
     262     return isDefined; 
     263  } 
     264 
     265 
    258266  void cxios_set_axis_size(axis_Ptr axis_hdl, int size) 
    259267  { 
    260      CTimer::get("XIOS").resume(); 
     268    CTimer::get("XIOS").resume(); 
    261269    axis_hdl->size.setValue(size); 
    262      CTimer::get("XIOS").suspend(); 
    263   } 
    264    
     270    CTimer::get("XIOS").suspend(); 
     271  } 
     272 
    265273  void cxios_get_axis_size(axis_Ptr axis_hdl, int* size) 
    266274  { 
     275    CTimer::get("XIOS").resume(); 
    267276    *size = axis_hdl->size.getInheritedValue(); 
    268   } 
    269    
    270   bool cxios_is_defined_axis_size(axis_Ptr axis_hdl ) 
    271   { 
    272      CTimer::get("XIOS").resume(); 
    273     return axis_hdl->size.hasInheritedValue(); 
    274      CTimer::get("XIOS").suspend(); 
    275   } 
    276    
    277    
    278    
     277    CTimer::get("XIOS").suspend(); 
     278  } 
     279 
     280  bool cxios_is_defined_axis_size(axis_Ptr axis_hdl) 
     281  { 
     282     CTimer::get("XIOS").resume(); 
     283     bool isDefined = axis_hdl->size.hasInheritedValue(); 
     284     CTimer::get("XIOS").suspend(); 
     285     return isDefined; 
     286  } 
     287 
     288 
    279289  void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size) 
    280290  { 
    281291    std::string standard_name_str; 
    282     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    283      CTimer::get("XIOS").resume(); 
     292    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     293    CTimer::get("XIOS").resume(); 
    284294    axis_hdl->standard_name.setValue(standard_name_str); 
    285      CTimer::get("XIOS").suspend(); 
    286   } 
    287    
     295    CTimer::get("XIOS").suspend(); 
     296  } 
     297 
    288298  void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size) 
    289299  { 
    290      CTimer::get("XIOS").resume(); 
    291     if(!string_copy(axis_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    292       ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    293      CTimer::get("XIOS").suspend(); 
    294   } 
    295    
    296   bool cxios_is_defined_axis_standard_name(axis_Ptr axis_hdl ) 
    297   { 
    298      CTimer::get("XIOS").resume(); 
    299     return axis_hdl->standard_name.hasInheritedValue(); 
    300      CTimer::get("XIOS").suspend(); 
    301   } 
    302    
    303    
    304    
     300    CTimer::get("XIOS").resume(); 
     301    if (!string_copy(axis_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     302      ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     303    CTimer::get("XIOS").suspend(); 
     304  } 
     305 
     306  bool cxios_is_defined_axis_standard_name(axis_Ptr axis_hdl) 
     307  { 
     308     CTimer::get("XIOS").resume(); 
     309     bool isDefined = axis_hdl->standard_name.hasInheritedValue(); 
     310     CTimer::get("XIOS").suspend(); 
     311     return isDefined; 
     312  } 
     313 
     314 
    305315  void cxios_set_axis_unit(axis_Ptr axis_hdl, const char * unit, int unit_size) 
    306316  { 
    307317    std::string unit_str; 
    308     if(!cstr2string(unit, unit_size, unit_str)) return; 
    309      CTimer::get("XIOS").resume(); 
     318    if (!cstr2string(unit, unit_size, unit_str)) return; 
     319    CTimer::get("XIOS").resume(); 
    310320    axis_hdl->unit.setValue(unit_str); 
    311      CTimer::get("XIOS").suspend(); 
    312   } 
    313    
     321    CTimer::get("XIOS").suspend(); 
     322  } 
     323 
    314324  void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size) 
    315325  { 
    316      CTimer::get("XIOS").resume(); 
    317     if(!string_copy(axis_hdl->unit.getInheritedValue(),unit , unit_size)) 
    318       ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    319      CTimer::get("XIOS").suspend(); 
    320   } 
    321    
    322   bool cxios_is_defined_axis_unit(axis_Ptr axis_hdl ) 
    323   { 
    324      CTimer::get("XIOS").resume(); 
    325     return axis_hdl->unit.hasInheritedValue(); 
    326      CTimer::get("XIOS").suspend(); 
    327   } 
    328    
    329    
    330    
     326    CTimer::get("XIOS").resume(); 
     327    if (!string_copy(axis_hdl->unit.getInheritedValue(), unit, unit_size)) 
     328      ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", << "Input string is too short"); 
     329    CTimer::get("XIOS").suspend(); 
     330  } 
     331 
     332  bool cxios_is_defined_axis_unit(axis_Ptr axis_hdl) 
     333  { 
     334     CTimer::get("XIOS").resume(); 
     335     bool isDefined = axis_hdl->unit.hasInheritedValue(); 
     336     CTimer::get("XIOS").suspend(); 
     337     return isDefined; 
     338  } 
     339 
     340 
    331341  void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1) 
    332342  { 
    333343    CTimer::get("XIOS").resume(); 
    334     CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     344    CArray<double,1> tmp(value, shape(extent1), neverDeleteData); 
    335345    axis_hdl->value.reference(tmp.copy()); 
    336346     CTimer::get("XIOS").suspend(); 
    337347  } 
    338    
     348 
    339349  void cxios_get_axis_value(axis_Ptr axis_hdl, double* value, int extent1) 
    340350  { 
    341351    CTimer::get("XIOS").resume(); 
    342     CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
    343     tmp=axis_hdl->value.getInheritedValue() ; 
    344      CTimer::get("XIOS").suspend(); 
    345   } 
    346    
    347   bool cxios_is_defined_axis_value(axis_Ptr axis_hdl ) 
    348   { 
    349      CTimer::get("XIOS").resume(); 
    350     return axis_hdl->value.hasInheritedValue(); 
    351      CTimer::get("XIOS").suspend(); 
    352   } 
    353    
    354    
    355    
     352    CArray<double,1> tmp(value, shape(extent1), neverDeleteData); 
     353    tmp=axis_hdl->value.getInheritedValue(); 
     354     CTimer::get("XIOS").suspend(); 
     355  } 
     356 
     357  bool cxios_is_defined_axis_value(axis_Ptr axis_hdl) 
     358  { 
     359     CTimer::get("XIOS").resume(); 
     360     bool isDefined = axis_hdl->value.hasInheritedValue(); 
     361     CTimer::get("XIOS").suspend(); 
     362     return isDefined; 
     363  } 
     364 
     365 
    356366  void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin) 
    357367  { 
    358      CTimer::get("XIOS").resume(); 
     368    CTimer::get("XIOS").resume(); 
    359369    axis_hdl->zoom_begin.setValue(zoom_begin); 
    360      CTimer::get("XIOS").suspend(); 
    361   } 
    362    
     370    CTimer::get("XIOS").suspend(); 
     371  } 
     372 
    363373  void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin) 
    364374  { 
     375    CTimer::get("XIOS").resume(); 
    365376    *zoom_begin = axis_hdl->zoom_begin.getInheritedValue(); 
    366   } 
    367    
    368   bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl ) 
    369   { 
    370      CTimer::get("XIOS").resume(); 
    371     return axis_hdl->zoom_begin.hasInheritedValue(); 
    372      CTimer::get("XIOS").suspend(); 
    373   } 
    374    
    375    
    376    
     377    CTimer::get("XIOS").suspend(); 
     378  } 
     379 
     380  bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl) 
     381  { 
     382     CTimer::get("XIOS").resume(); 
     383     bool isDefined = axis_hdl->zoom_begin.hasInheritedValue(); 
     384     CTimer::get("XIOS").suspend(); 
     385     return isDefined; 
     386  } 
     387 
     388 
    377389  void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end) 
    378390  { 
    379      CTimer::get("XIOS").resume(); 
     391    CTimer::get("XIOS").resume(); 
    380392    axis_hdl->zoom_end.setValue(zoom_end); 
    381      CTimer::get("XIOS").suspend(); 
    382   } 
    383    
     393    CTimer::get("XIOS").suspend(); 
     394  } 
     395 
    384396  void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end) 
    385397  { 
     398    CTimer::get("XIOS").resume(); 
    386399    *zoom_end = axis_hdl->zoom_end.getInheritedValue(); 
    387   } 
    388    
    389   bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl ) 
    390   { 
    391      CTimer::get("XIOS").resume(); 
    392     return axis_hdl->zoom_end.hasInheritedValue(); 
    393      CTimer::get("XIOS").suspend(); 
    394   } 
    395    
    396    
    397    
     400    CTimer::get("XIOS").suspend(); 
     401  } 
     402 
     403  bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl) 
     404  { 
     405     CTimer::get("XIOS").resume(); 
     406     bool isDefined = axis_hdl->zoom_end.hasInheritedValue(); 
     407     CTimer::get("XIOS").suspend(); 
     408     return isDefined; 
     409  } 
     410 
     411 
    398412  void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size) 
    399413  { 
    400      CTimer::get("XIOS").resume(); 
     414    CTimer::get("XIOS").resume(); 
    401415    axis_hdl->zoom_size.setValue(zoom_size); 
    402      CTimer::get("XIOS").suspend(); 
    403   } 
    404    
     416    CTimer::get("XIOS").suspend(); 
     417  } 
     418 
    405419  void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size) 
    406420  { 
     421    CTimer::get("XIOS").resume(); 
    407422    *zoom_size = axis_hdl->zoom_size.getInheritedValue(); 
    408   } 
    409    
    410   bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl ) 
    411   { 
    412      CTimer::get("XIOS").resume(); 
    413     return axis_hdl->zoom_size.hasInheritedValue(); 
    414      CTimer::get("XIOS").suspend(); 
    415   } 
    416    
    417    
    418    
    419    
     423    CTimer::get("XIOS").suspend(); 
     424  } 
     425 
     426  bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl) 
     427  { 
     428     CTimer::get("XIOS").resume(); 
     429     bool isDefined = axis_hdl->zoom_size.hasInheritedValue(); 
     430     CTimer::get("XIOS").suspend(); 
     431     return isDefined; 
     432  } 
    420433} 

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

    r555 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CAxisGroup*  axisgroup_Ptr; 
    19    
     18  typedef xios::CAxisGroup* axisgroup_Ptr; 
     19 
    2020  void cxios_set_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, const char * axis_ref, int axis_ref_size) 
    2121  { 
    2222    std::string axis_ref_str; 
    23     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    24      CTimer::get("XIOS").resume(); 
     23    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     24    CTimer::get("XIOS").resume(); 
    2525    axisgroup_hdl->axis_ref.setValue(axis_ref_str); 
    26      CTimer::get("XIOS").suspend(); 
    27   } 
    28    
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
    2929  void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size) 
    3030  { 
    31      CTimer::get("XIOS").resume(); 
    32     if(!string_copy(axisgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    33       ERROR("void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    34      CTimer::get("XIOS").suspend(); 
    35   } 
    36    
    37   bool cxios_is_defined_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl ) 
    38   { 
    39      CTimer::get("XIOS").resume(); 
    40     return axisgroup_hdl->axis_ref.hasInheritedValue(); 
    41      CTimer::get("XIOS").suspend(); 
    42   } 
    43    
    44    
    45    
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(axisgroup_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size)) 
     33      ERROR("void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = axisgroup_hdl->axis_ref.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    4646  void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin) 
    4747  { 
    48      CTimer::get("XIOS").resume(); 
     48    CTimer::get("XIOS").resume(); 
    4949    axisgroup_hdl->data_begin.setValue(data_begin); 
    50      CTimer::get("XIOS").suspend(); 
    51   } 
    52    
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
    5353  void cxios_get_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int* data_begin) 
    5454  { 
     55    CTimer::get("XIOS").resume(); 
    5556    *data_begin = axisgroup_hdl->data_begin.getInheritedValue(); 
    56   } 
    57    
    58   bool cxios_is_defined_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return axisgroup_hdl->data_begin.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = axisgroup_hdl->data_begin.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int extent1) 
    6870  { 
    6971    CTimer::get("XIOS").resume(); 
    70     CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ; 
     72    CArray<int,1> tmp(data_index, shape(extent1), neverDeleteData); 
    7173    axisgroup_hdl->data_index.reference(tmp.copy()); 
    7274     CTimer::get("XIOS").suspend(); 
    7375  } 
    74    
     76 
    7577  void cxios_get_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int extent1) 
    7678  { 
    7779    CTimer::get("XIOS").resume(); 
    78     CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ; 
    79     tmp=axisgroup_hdl->data_index.getInheritedValue() ; 
    80      CTimer::get("XIOS").suspend(); 
    81   } 
    82    
    83   bool cxios_is_defined_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl ) 
    84   { 
    85      CTimer::get("XIOS").resume(); 
    86     return axisgroup_hdl->data_index.hasInheritedValue(); 
    87      CTimer::get("XIOS").suspend(); 
    88   } 
    89    
    90    
    91    
     80    CArray<int,1> tmp(data_index, shape(extent1), neverDeleteData); 
     81    tmp=axisgroup_hdl->data_index.getInheritedValue(); 
     82     CTimer::get("XIOS").suspend(); 
     83  } 
     84 
     85  bool cxios_is_defined_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl) 
     86  { 
     87     CTimer::get("XIOS").resume(); 
     88     bool isDefined = axisgroup_hdl->data_index.hasInheritedValue(); 
     89     CTimer::get("XIOS").suspend(); 
     90     return isDefined; 
     91  } 
     92 
     93 
    9294  void cxios_set_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int data_n) 
    9395  { 
    94      CTimer::get("XIOS").resume(); 
     96    CTimer::get("XIOS").resume(); 
    9597    axisgroup_hdl->data_n.setValue(data_n); 
    96      CTimer::get("XIOS").suspend(); 
    97   } 
    98    
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
    99101  void cxios_get_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int* data_n) 
    100102  { 
     103    CTimer::get("XIOS").resume(); 
    101104    *data_n = axisgroup_hdl->data_n.getInheritedValue(); 
    102   } 
    103    
    104   bool cxios_is_defined_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl ) 
    105   { 
    106      CTimer::get("XIOS").resume(); 
    107     return axisgroup_hdl->data_n.hasInheritedValue(); 
    108      CTimer::get("XIOS").suspend(); 
    109   } 
    110    
    111    
    112    
     105    CTimer::get("XIOS").suspend(); 
     106  } 
     107 
     108  bool cxios_is_defined_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl) 
     109  { 
     110     CTimer::get("XIOS").resume(); 
     111     bool isDefined = axisgroup_hdl->data_n.hasInheritedValue(); 
     112     CTimer::get("XIOS").suspend(); 
     113     return isDefined; 
     114  } 
     115 
     116 
    113117  void cxios_set_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, const char * group_ref, int group_ref_size) 
    114118  { 
    115119    std::string group_ref_str; 
    116     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    117      CTimer::get("XIOS").resume(); 
     120    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     121    CTimer::get("XIOS").resume(); 
    118122    axisgroup_hdl->group_ref.setValue(group_ref_str); 
    119      CTimer::get("XIOS").suspend(); 
    120   } 
    121    
     123    CTimer::get("XIOS").suspend(); 
     124  } 
     125 
    122126  void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size) 
    123127  { 
    124      CTimer::get("XIOS").resume(); 
    125     if(!string_copy(axisgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    126       ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    127      CTimer::get("XIOS").suspend(); 
    128   } 
    129    
    130   bool cxios_is_defined_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl ) 
    131   { 
    132      CTimer::get("XIOS").resume(); 
    133     return axisgroup_hdl->group_ref.hasInheritedValue(); 
    134      CTimer::get("XIOS").suspend(); 
    135   } 
    136    
    137    
    138    
     128    CTimer::get("XIOS").resume(); 
     129    if (!string_copy(axisgroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     130      ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     131    CTimer::get("XIOS").suspend(); 
     132  } 
     133 
     134  bool cxios_is_defined_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl) 
     135  { 
     136     CTimer::get("XIOS").resume(); 
     137     bool isDefined = axisgroup_hdl->group_ref.hasInheritedValue(); 
     138     CTimer::get("XIOS").suspend(); 
     139     return isDefined; 
     140  } 
     141 
     142 
    139143  void cxios_set_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int ibegin) 
    140144  { 
    141      CTimer::get("XIOS").resume(); 
     145    CTimer::get("XIOS").resume(); 
    142146    axisgroup_hdl->ibegin.setValue(ibegin); 
    143      CTimer::get("XIOS").suspend(); 
    144   } 
    145    
     147    CTimer::get("XIOS").suspend(); 
     148  } 
     149 
    146150  void cxios_get_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int* ibegin) 
    147151  { 
     152    CTimer::get("XIOS").resume(); 
    148153    *ibegin = axisgroup_hdl->ibegin.getInheritedValue(); 
    149   } 
    150    
    151   bool cxios_is_defined_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl ) 
    152   { 
    153      CTimer::get("XIOS").resume(); 
    154     return axisgroup_hdl->ibegin.hasInheritedValue(); 
    155      CTimer::get("XIOS").suspend(); 
    156   } 
    157    
    158    
    159    
     154    CTimer::get("XIOS").suspend(); 
     155  } 
     156 
     157  bool cxios_is_defined_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl) 
     158  { 
     159     CTimer::get("XIOS").resume(); 
     160     bool isDefined = axisgroup_hdl->ibegin.hasInheritedValue(); 
     161     CTimer::get("XIOS").suspend(); 
     162     return isDefined; 
     163  } 
     164 
     165 
    160166  void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size) 
    161167  { 
    162168    std::string long_name_str; 
    163     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    164      CTimer::get("XIOS").resume(); 
     169    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     170    CTimer::get("XIOS").resume(); 
    165171    axisgroup_hdl->long_name.setValue(long_name_str); 
    166      CTimer::get("XIOS").suspend(); 
    167   } 
    168    
     172    CTimer::get("XIOS").suspend(); 
     173  } 
     174 
    169175  void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size) 
    170176  { 
    171      CTimer::get("XIOS").resume(); 
    172     if(!string_copy(axisgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    173       ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    174      CTimer::get("XIOS").suspend(); 
    175   } 
    176    
    177   bool cxios_is_defined_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl ) 
    178   { 
    179      CTimer::get("XIOS").resume(); 
    180     return axisgroup_hdl->long_name.hasInheritedValue(); 
    181      CTimer::get("XIOS").suspend(); 
    182   } 
    183    
    184    
    185    
     177    CTimer::get("XIOS").resume(); 
     178    if (!string_copy(axisgroup_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     179      ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     180    CTimer::get("XIOS").suspend(); 
     181  } 
     182 
     183  bool cxios_is_defined_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl) 
     184  { 
     185     CTimer::get("XIOS").resume(); 
     186     bool isDefined = axisgroup_hdl->long_name.hasInheritedValue(); 
     187     CTimer::get("XIOS").suspend(); 
     188     return isDefined; 
     189  } 
     190 
     191 
    186192  void cxios_set_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int extent1) 
    187193  { 
    188194    CTimer::get("XIOS").resume(); 
    189     CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ; 
     195    CArray<bool,1> tmp(mask, shape(extent1), neverDeleteData); 
    190196    axisgroup_hdl->mask.reference(tmp.copy()); 
    191197     CTimer::get("XIOS").suspend(); 
    192198  } 
    193    
     199 
    194200  void cxios_get_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int extent1) 
    195201  { 
    196202    CTimer::get("XIOS").resume(); 
    197     CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ; 
    198     tmp=axisgroup_hdl->mask.getInheritedValue() ; 
    199      CTimer::get("XIOS").suspend(); 
    200   } 
    201    
    202   bool cxios_is_defined_axisgroup_mask(axisgroup_Ptr axisgroup_hdl ) 
    203   { 
    204      CTimer::get("XIOS").resume(); 
    205     return axisgroup_hdl->mask.hasInheritedValue(); 
    206      CTimer::get("XIOS").suspend(); 
    207   } 
    208    
    209    
    210    
     203    CArray<bool,1> tmp(mask, shape(extent1), neverDeleteData); 
     204    tmp=axisgroup_hdl->mask.getInheritedValue(); 
     205     CTimer::get("XIOS").suspend(); 
     206  } 
     207 
     208  bool cxios_is_defined_axisgroup_mask(axisgroup_Ptr axisgroup_hdl) 
     209  { 
     210     CTimer::get("XIOS").resume(); 
     211     bool isDefined = axisgroup_hdl->mask.hasInheritedValue(); 
     212     CTimer::get("XIOS").suspend(); 
     213     return isDefined; 
     214  } 
     215 
     216 
    211217  void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size) 
    212218  { 
    213219    std::string name_str; 
    214     if(!cstr2string(name, name_size, name_str)) return; 
    215      CTimer::get("XIOS").resume(); 
     220    if (!cstr2string(name, name_size, name_str)) return; 
     221    CTimer::get("XIOS").resume(); 
    216222    axisgroup_hdl->name.setValue(name_str); 
    217      CTimer::get("XIOS").suspend(); 
    218   } 
    219    
     223    CTimer::get("XIOS").suspend(); 
     224  } 
     225 
    220226  void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size) 
    221227  { 
    222      CTimer::get("XIOS").resume(); 
    223     if(!string_copy(axisgroup_hdl->name.getInheritedValue(),name , name_size)) 
    224       ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    225      CTimer::get("XIOS").suspend(); 
    226   } 
    227    
    228   bool cxios_is_defined_axisgroup_name(axisgroup_Ptr axisgroup_hdl ) 
    229   { 
    230      CTimer::get("XIOS").resume(); 
    231     return axisgroup_hdl->name.hasInheritedValue(); 
    232      CTimer::get("XIOS").suspend(); 
    233   } 
    234    
    235    
    236    
     228    CTimer::get("XIOS").resume(); 
     229    if (!string_copy(axisgroup_hdl->name.getInheritedValue(), name, name_size)) 
     230      ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     231    CTimer::get("XIOS").suspend(); 
     232  } 
     233 
     234  bool cxios_is_defined_axisgroup_name(axisgroup_Ptr axisgroup_hdl) 
     235  { 
     236     CTimer::get("XIOS").resume(); 
     237     bool isDefined = axisgroup_hdl->name.hasInheritedValue(); 
     238     CTimer::get("XIOS").suspend(); 
     239     return isDefined; 
     240  } 
     241 
     242 
    237243  void cxios_set_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int ni) 
    238244  { 
    239      CTimer::get("XIOS").resume(); 
     245    CTimer::get("XIOS").resume(); 
    240246    axisgroup_hdl->ni.setValue(ni); 
    241      CTimer::get("XIOS").suspend(); 
    242   } 
    243    
     247    CTimer::get("XIOS").suspend(); 
     248  } 
     249 
    244250  void cxios_get_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int* ni) 
    245251  { 
     252    CTimer::get("XIOS").resume(); 
    246253    *ni = axisgroup_hdl->ni.getInheritedValue(); 
    247   } 
    248    
    249   bool cxios_is_defined_axisgroup_ni(axisgroup_Ptr axisgroup_hdl ) 
    250   { 
    251      CTimer::get("XIOS").resume(); 
    252     return axisgroup_hdl->ni.hasInheritedValue(); 
    253      CTimer::get("XIOS").suspend(); 
    254   } 
    255    
    256    
    257    
     254    CTimer::get("XIOS").suspend(); 
     255  } 
     256 
     257  bool cxios_is_defined_axisgroup_ni(axisgroup_Ptr axisgroup_hdl) 
     258  { 
     259     CTimer::get("XIOS").resume(); 
     260     bool isDefined = axisgroup_hdl->ni.hasInheritedValue(); 
     261     CTimer::get("XIOS").suspend(); 
     262     return isDefined; 
     263  } 
     264 
     265 
    258266  void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size) 
    259267  { 
    260268    std::string positive_str; 
    261     if(!cstr2string(positive, positive_size, positive_str)) return; 
    262      CTimer::get("XIOS").resume(); 
     269    if (!cstr2string(positive, positive_size, positive_str)) return; 
     270    CTimer::get("XIOS").resume(); 
    263271    axisgroup_hdl->positive.fromString(positive_str); 
    264      CTimer::get("XIOS").suspend(); 
    265   } 
    266    
     272    CTimer::get("XIOS").suspend(); 
     273  } 
     274 
    267275  void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size) 
    268276  { 
    269      CTimer::get("XIOS").resume(); 
    270     if(!string_copy(axisgroup_hdl->positive.getInheritedStringValue(),positive , positive_size)) 
    271       ERROR("void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)", <<"Input string is to short"); 
    272      CTimer::get("XIOS").suspend(); 
    273   } 
    274    
    275   bool cxios_is_defined_axisgroup_positive(axisgroup_Ptr axisgroup_hdl ) 
    276   { 
    277      CTimer::get("XIOS").resume(); 
    278     return axisgroup_hdl->positive.hasInheritedValue(); 
    279      CTimer::get("XIOS").suspend(); 
    280   } 
    281    
    282    
    283    
     277    CTimer::get("XIOS").resume(); 
     278    if (!string_copy(axisgroup_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     279      ERROR("void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     280    CTimer::get("XIOS").suspend(); 
     281  } 
     282 
     283  bool cxios_is_defined_axisgroup_positive(axisgroup_Ptr axisgroup_hdl) 
     284  { 
     285     CTimer::get("XIOS").resume(); 
     286     bool isDefined = axisgroup_hdl->positive.hasInheritedValue(); 
     287     CTimer::get("XIOS").suspend(); 
     288     return isDefined; 
     289  } 
     290 
     291 
    284292  void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size) 
    285293  { 
    286      CTimer::get("XIOS").resume(); 
     294    CTimer::get("XIOS").resume(); 
    287295    axisgroup_hdl->size.setValue(size); 
    288      CTimer::get("XIOS").suspend(); 
    289   } 
    290    
     296    CTimer::get("XIOS").suspend(); 
     297  } 
     298 
    291299  void cxios_get_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int* size) 
    292300  { 
     301    CTimer::get("XIOS").resume(); 
    293302    *size = axisgroup_hdl->size.getInheritedValue(); 
    294   } 
    295    
    296   bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl ) 
    297   { 
    298      CTimer::get("XIOS").resume(); 
    299     return axisgroup_hdl->size.hasInheritedValue(); 
    300      CTimer::get("XIOS").suspend(); 
    301   } 
    302    
    303    
    304    
     303    CTimer::get("XIOS").suspend(); 
     304  } 
     305 
     306  bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl) 
     307  { 
     308     CTimer::get("XIOS").resume(); 
     309     bool isDefined = axisgroup_hdl->size.hasInheritedValue(); 
     310     CTimer::get("XIOS").suspend(); 
     311     return isDefined; 
     312  } 
     313 
     314 
    305315  void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size) 
    306316  { 
    307317    std::string standard_name_str; 
    308     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    309      CTimer::get("XIOS").resume(); 
     318    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     319    CTimer::get("XIOS").resume(); 
    310320    axisgroup_hdl->standard_name.setValue(standard_name_str); 
    311      CTimer::get("XIOS").suspend(); 
    312   } 
    313    
     321    CTimer::get("XIOS").suspend(); 
     322  } 
     323 
    314324  void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size) 
    315325  { 
    316      CTimer::get("XIOS").resume(); 
    317     if(!string_copy(axisgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    318       ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    319      CTimer::get("XIOS").suspend(); 
    320   } 
    321    
    322   bool cxios_is_defined_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl ) 
    323   { 
    324      CTimer::get("XIOS").resume(); 
    325     return axisgroup_hdl->standard_name.hasInheritedValue(); 
    326      CTimer::get("XIOS").suspend(); 
    327   } 
    328    
    329    
    330    
     326    CTimer::get("XIOS").resume(); 
     327    if (!string_copy(axisgroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     328      ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     329    CTimer::get("XIOS").suspend(); 
     330  } 
     331 
     332  bool cxios_is_defined_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl) 
     333  { 
     334     CTimer::get("XIOS").resume(); 
     335     bool isDefined = axisgroup_hdl->standard_name.hasInheritedValue(); 
     336     CTimer::get("XIOS").suspend(); 
     337     return isDefined; 
     338  } 
     339 
     340 
    331341  void cxios_set_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, const char * unit, int unit_size) 
    332342  { 
    333343    std::string unit_str; 
    334     if(!cstr2string(unit, unit_size, unit_str)) return; 
    335      CTimer::get("XIOS").resume(); 
     344    if (!cstr2string(unit, unit_size, unit_str)) return; 
     345    CTimer::get("XIOS").resume(); 
    336346    axisgroup_hdl->unit.setValue(unit_str); 
    337      CTimer::get("XIOS").suspend(); 
    338   } 
    339    
     347    CTimer::get("XIOS").suspend(); 
     348  } 
     349 
    340350  void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size) 
    341351  { 
    342      CTimer::get("XIOS").resume(); 
    343     if(!string_copy(axisgroup_hdl->unit.getInheritedValue(),unit , unit_size)) 
    344       ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    345      CTimer::get("XIOS").suspend(); 
    346   } 
    347    
    348   bool cxios_is_defined_axisgroup_unit(axisgroup_Ptr axisgroup_hdl ) 
    349   { 
    350      CTimer::get("XIOS").resume(); 
    351     return axisgroup_hdl->unit.hasInheritedValue(); 
    352      CTimer::get("XIOS").suspend(); 
    353   } 
    354    
    355    
    356    
     352    CTimer::get("XIOS").resume(); 
     353    if (!string_copy(axisgroup_hdl->unit.getInheritedValue(), unit, unit_size)) 
     354      ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", << "Input string is too short"); 
     355    CTimer::get("XIOS").suspend(); 
     356  } 
     357 
     358  bool cxios_is_defined_axisgroup_unit(axisgroup_Ptr axisgroup_hdl) 
     359  { 
     360     CTimer::get("XIOS").resume(); 
     361     bool isDefined = axisgroup_hdl->unit.hasInheritedValue(); 
     362     CTimer::get("XIOS").suspend(); 
     363     return isDefined; 
     364  } 
     365 
     366 
    357367  void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1) 
    358368  { 
    359369    CTimer::get("XIOS").resume(); 
    360     CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     370    CArray<double,1> tmp(value, shape(extent1), neverDeleteData); 
    361371    axisgroup_hdl->value.reference(tmp.copy()); 
    362372     CTimer::get("XIOS").suspend(); 
    363373  } 
    364    
     374 
    365375  void cxios_get_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1) 
    366376  { 
    367377    CTimer::get("XIOS").resume(); 
    368     CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
    369     tmp=axisgroup_hdl->value.getInheritedValue() ; 
    370      CTimer::get("XIOS").suspend(); 
    371   } 
    372    
    373   bool cxios_is_defined_axisgroup_value(axisgroup_Ptr axisgroup_hdl ) 
    374   { 
    375      CTimer::get("XIOS").resume(); 
    376     return axisgroup_hdl->value.hasInheritedValue(); 
    377      CTimer::get("XIOS").suspend(); 
    378   } 
    379    
    380    
    381    
     378    CArray<double,1> tmp(value, shape(extent1), neverDeleteData); 
     379    tmp=axisgroup_hdl->value.getInheritedValue(); 
     380     CTimer::get("XIOS").suspend(); 
     381  } 
     382 
     383  bool cxios_is_defined_axisgroup_value(axisgroup_Ptr axisgroup_hdl) 
     384  { 
     385     CTimer::get("XIOS").resume(); 
     386     bool isDefined = axisgroup_hdl->value.hasInheritedValue(); 
     387     CTimer::get("XIOS").suspend(); 
     388     return isDefined; 
     389  } 
     390 
     391 
    382392  void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin) 
    383393  { 
    384      CTimer::get("XIOS").resume(); 
     394    CTimer::get("XIOS").resume(); 
    385395    axisgroup_hdl->zoom_begin.setValue(zoom_begin); 
    386      CTimer::get("XIOS").suspend(); 
    387   } 
    388    
     396    CTimer::get("XIOS").suspend(); 
     397  } 
     398 
    389399  void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin) 
    390400  { 
     401    CTimer::get("XIOS").resume(); 
    391402    *zoom_begin = axisgroup_hdl->zoom_begin.getInheritedValue(); 
    392   } 
    393    
    394   bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl ) 
    395   { 
    396      CTimer::get("XIOS").resume(); 
    397     return axisgroup_hdl->zoom_begin.hasInheritedValue(); 
    398      CTimer::get("XIOS").suspend(); 
    399   } 
    400    
    401    
    402    
     403    CTimer::get("XIOS").suspend(); 
     404  } 
     405 
     406  bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl) 
     407  { 
     408     CTimer::get("XIOS").resume(); 
     409     bool isDefined = axisgroup_hdl->zoom_begin.hasInheritedValue(); 
     410     CTimer::get("XIOS").suspend(); 
     411     return isDefined; 
     412  } 
     413 
     414 
    403415  void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end) 
    404416  { 
    405      CTimer::get("XIOS").resume(); 
     417    CTimer::get("XIOS").resume(); 
    406418    axisgroup_hdl->zoom_end.setValue(zoom_end); 
    407      CTimer::get("XIOS").suspend(); 
    408   } 
    409    
     419    CTimer::get("XIOS").suspend(); 
     420  } 
     421 
    410422  void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end) 
    411423  { 
     424    CTimer::get("XIOS").resume(); 
    412425    *zoom_end = axisgroup_hdl->zoom_end.getInheritedValue(); 
    413   } 
    414    
    415   bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl ) 
    416   { 
    417      CTimer::get("XIOS").resume(); 
    418     return axisgroup_hdl->zoom_end.hasInheritedValue(); 
    419      CTimer::get("XIOS").suspend(); 
    420   } 
    421    
    422    
    423    
     426    CTimer::get("XIOS").suspend(); 
     427  } 
     428 
     429  bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl) 
     430  { 
     431     CTimer::get("XIOS").resume(); 
     432     bool isDefined = axisgroup_hdl->zoom_end.hasInheritedValue(); 
     433     CTimer::get("XIOS").suspend(); 
     434     return isDefined; 
     435  } 
     436 
     437 
    424438  void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size) 
    425439  { 
    426      CTimer::get("XIOS").resume(); 
     440    CTimer::get("XIOS").resume(); 
    427441    axisgroup_hdl->zoom_size.setValue(zoom_size); 
    428      CTimer::get("XIOS").suspend(); 
    429   } 
    430    
     442    CTimer::get("XIOS").suspend(); 
     443  } 
     444 
    431445  void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size) 
    432446  { 
     447    CTimer::get("XIOS").resume(); 
    433448    *zoom_size = axisgroup_hdl->zoom_size.getInheritedValue(); 
    434   } 
    435    
    436   bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl ) 
    437   { 
    438      CTimer::get("XIOS").resume(); 
    439     return axisgroup_hdl->zoom_size.hasInheritedValue(); 
    440      CTimer::get("XIOS").suspend(); 
    441   } 
    442    
    443    
    444    
    445    
     449    CTimer::get("XIOS").suspend(); 
     450  } 
     451 
     452  bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl) 
     453  { 
     454     CTimer::get("XIOS").resume(); 
     455     bool isDefined = axisgroup_hdl->zoom_size.hasInheritedValue(); 
     456     CTimer::get("XIOS").suspend(); 
     457     return isDefined; 
     458  } 
    446459} 

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

    r550 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CCalendarWrapper*  calendar_wrapper_Ptr; 
    19    
     18  typedef xios::CCalendarWrapper* calendar_wrapper_Ptr; 
     19 
    2020  void cxios_set_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int day_length) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    calendar_wrapper_hdl->day_length.setValue(day_length); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int* day_length) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *day_length = calendar_wrapper_hdl->day_length.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return calendar_wrapper_hdl->day_length.hasInheritedValue(); 
    36      CTimer::get("XIOS").suspend(); 
    37   } 
    38    
    39    
    40    
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = calendar_wrapper_hdl->day_length.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_calendar_wrapper_leap_year_drift(calendar_wrapper_Ptr calendar_wrapper_hdl, double leap_year_drift) 
    4244  { 
    43      CTimer::get("XIOS").resume(); 
     45    CTimer::get("XIOS").resume(); 
    4446    calendar_wrapper_hdl->leap_year_drift.setValue(leap_year_drift); 
    45      CTimer::get("XIOS").suspend(); 
    46   } 
    47    
     47    CTimer::get("XIOS").suspend(); 
     48  } 
     49 
    4850  void cxios_get_calendar_wrapper_leap_year_drift(calendar_wrapper_Ptr calendar_wrapper_hdl, double* leap_year_drift) 
    4951  { 
     52    CTimer::get("XIOS").resume(); 
    5053    *leap_year_drift = calendar_wrapper_hdl->leap_year_drift.getInheritedValue(); 
    51   } 
    52    
    53   bool cxios_is_defined_calendar_wrapper_leap_year_drift(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    54   { 
    55      CTimer::get("XIOS").resume(); 
    56     return calendar_wrapper_hdl->leap_year_drift.hasInheritedValue(); 
    57      CTimer::get("XIOS").suspend(); 
    58   } 
    59    
    60    
    61    
     54    CTimer::get("XIOS").suspend(); 
     55  } 
     56 
     57  bool cxios_is_defined_calendar_wrapper_leap_year_drift(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     58  { 
     59     CTimer::get("XIOS").resume(); 
     60     bool isDefined = calendar_wrapper_hdl->leap_year_drift.hasInheritedValue(); 
     61     CTimer::get("XIOS").suspend(); 
     62     return isDefined; 
     63  } 
     64 
     65 
    6266  void cxios_set_calendar_wrapper_leap_year_drift_offset(calendar_wrapper_Ptr calendar_wrapper_hdl, double leap_year_drift_offset) 
    6367  { 
    64      CTimer::get("XIOS").resume(); 
     68    CTimer::get("XIOS").resume(); 
    6569    calendar_wrapper_hdl->leap_year_drift_offset.setValue(leap_year_drift_offset); 
    66      CTimer::get("XIOS").suspend(); 
    67   } 
    68    
     70    CTimer::get("XIOS").suspend(); 
     71  } 
     72 
    6973  void cxios_get_calendar_wrapper_leap_year_drift_offset(calendar_wrapper_Ptr calendar_wrapper_hdl, double* leap_year_drift_offset) 
    7074  { 
     75    CTimer::get("XIOS").resume(); 
    7176    *leap_year_drift_offset = calendar_wrapper_hdl->leap_year_drift_offset.getInheritedValue(); 
    72   } 
    73    
    74   bool cxios_is_defined_calendar_wrapper_leap_year_drift_offset(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    75   { 
    76      CTimer::get("XIOS").resume(); 
    77     return calendar_wrapper_hdl->leap_year_drift_offset.hasInheritedValue(); 
    78      CTimer::get("XIOS").suspend(); 
    79   } 
    80    
    81    
    82    
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  bool cxios_is_defined_calendar_wrapper_leap_year_drift_offset(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     81  { 
     82     CTimer::get("XIOS").resume(); 
     83     bool isDefined = calendar_wrapper_hdl->leap_year_drift_offset.hasInheritedValue(); 
     84     CTimer::get("XIOS").suspend(); 
     85     return isDefined; 
     86  } 
     87 
     88 
    8389  void cxios_set_calendar_wrapper_leap_year_month(calendar_wrapper_Ptr calendar_wrapper_hdl, int leap_year_month) 
    8490  { 
    85      CTimer::get("XIOS").resume(); 
     91    CTimer::get("XIOS").resume(); 
    8692    calendar_wrapper_hdl->leap_year_month.setValue(leap_year_month); 
    87      CTimer::get("XIOS").suspend(); 
    88   } 
    89    
     93    CTimer::get("XIOS").suspend(); 
     94  } 
     95 
    9096  void cxios_get_calendar_wrapper_leap_year_month(calendar_wrapper_Ptr calendar_wrapper_hdl, int* leap_year_month) 
    9197  { 
     98    CTimer::get("XIOS").resume(); 
    9299    *leap_year_month = calendar_wrapper_hdl->leap_year_month.getInheritedValue(); 
    93   } 
    94    
    95   bool cxios_is_defined_calendar_wrapper_leap_year_month(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    96   { 
    97      CTimer::get("XIOS").resume(); 
    98     return calendar_wrapper_hdl->leap_year_month.hasInheritedValue(); 
    99      CTimer::get("XIOS").suspend(); 
    100   } 
    101    
    102    
    103    
     100    CTimer::get("XIOS").suspend(); 
     101  } 
     102 
     103  bool cxios_is_defined_calendar_wrapper_leap_year_month(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     104  { 
     105     CTimer::get("XIOS").resume(); 
     106     bool isDefined = calendar_wrapper_hdl->leap_year_month.hasInheritedValue(); 
     107     CTimer::get("XIOS").suspend(); 
     108     return isDefined; 
     109  } 
     110 
     111 
    104112  void cxios_set_calendar_wrapper_month_lengths(calendar_wrapper_Ptr calendar_wrapper_hdl, int* month_lengths, int extent1) 
    105113  { 
    106114    CTimer::get("XIOS").resume(); 
    107     CArray<int,1> tmp(month_lengths,shape(extent1),neverDeleteData) ; 
     115    CArray<int,1> tmp(month_lengths, shape(extent1), neverDeleteData); 
    108116    calendar_wrapper_hdl->month_lengths.reference(tmp.copy()); 
    109117     CTimer::get("XIOS").suspend(); 
    110118  } 
    111    
     119 
    112120  void cxios_get_calendar_wrapper_month_lengths(calendar_wrapper_Ptr calendar_wrapper_hdl, int* month_lengths, int extent1) 
    113121  { 
    114122    CTimer::get("XIOS").resume(); 
    115     CArray<int,1> tmp(month_lengths,shape(extent1),neverDeleteData) ; 
    116     tmp=calendar_wrapper_hdl->month_lengths.getInheritedValue() ; 
    117      CTimer::get("XIOS").suspend(); 
    118   } 
    119    
    120   bool cxios_is_defined_calendar_wrapper_month_lengths(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    121   { 
    122      CTimer::get("XIOS").resume(); 
    123     return calendar_wrapper_hdl->month_lengths.hasInheritedValue(); 
    124      CTimer::get("XIOS").suspend(); 
    125   } 
    126    
    127    
    128    
     123    CArray<int,1> tmp(month_lengths, shape(extent1), neverDeleteData); 
     124    tmp=calendar_wrapper_hdl->month_lengths.getInheritedValue(); 
     125     CTimer::get("XIOS").suspend(); 
     126  } 
     127 
     128  bool cxios_is_defined_calendar_wrapper_month_lengths(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     129  { 
     130     CTimer::get("XIOS").resume(); 
     131     bool isDefined = calendar_wrapper_hdl->month_lengths.hasInheritedValue(); 
     132     CTimer::get("XIOS").suspend(); 
     133     return isDefined; 
     134  } 
     135 
     136 
    129137  void cxios_set_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * start_date, int start_date_size) 
    130138  { 
    131139    std::string start_date_str; 
    132     if(!cstr2string(start_date, start_date_size, start_date_str)) return; 
    133      CTimer::get("XIOS").resume(); 
     140    if (!cstr2string(start_date, start_date_size, start_date_str)) return; 
     141    CTimer::get("XIOS").resume(); 
    134142    calendar_wrapper_hdl->start_date.setValue(start_date_str); 
    135      CTimer::get("XIOS").suspend(); 
    136   } 
    137    
     143    CTimer::get("XIOS").suspend(); 
     144  } 
     145 
    138146  void cxios_get_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl, char * start_date, int start_date_size) 
    139147  { 
    140      CTimer::get("XIOS").resume(); 
    141     if(!string_copy(calendar_wrapper_hdl->start_date.getInheritedValue(),start_date , start_date_size)) 
    142       ERROR("void cxios_get_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl, char * start_date, int start_date_size)", <<"Input string is to short"); 
    143      CTimer::get("XIOS").suspend(); 
    144   } 
    145    
    146   bool cxios_is_defined_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    147   { 
    148      CTimer::get("XIOS").resume(); 
    149     return calendar_wrapper_hdl->start_date.hasInheritedValue(); 
    150      CTimer::get("XIOS").suspend(); 
    151   } 
    152    
    153    
    154    
     148    CTimer::get("XIOS").resume(); 
     149    if (!string_copy(calendar_wrapper_hdl->start_date.getInheritedValue(), start_date, start_date_size)) 
     150      ERROR("void cxios_get_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl, char * start_date, int start_date_size)", << "Input string is too short"); 
     151    CTimer::get("XIOS").suspend(); 
     152  } 
     153 
     154  bool cxios_is_defined_calendar_wrapper_start_date(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     155  { 
     156     CTimer::get("XIOS").resume(); 
     157     bool isDefined = calendar_wrapper_hdl->start_date.hasInheritedValue(); 
     158     CTimer::get("XIOS").suspend(); 
     159     return isDefined; 
     160  } 
     161 
     162 
    155163  void cxios_set_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * time_origin, int time_origin_size) 
    156164  { 
    157165    std::string time_origin_str; 
    158     if(!cstr2string(time_origin, time_origin_size, time_origin_str)) return; 
    159      CTimer::get("XIOS").resume(); 
     166    if (!cstr2string(time_origin, time_origin_size, time_origin_str)) return; 
     167    CTimer::get("XIOS").resume(); 
    160168    calendar_wrapper_hdl->time_origin.setValue(time_origin_str); 
    161      CTimer::get("XIOS").suspend(); 
    162   } 
    163    
     169    CTimer::get("XIOS").suspend(); 
     170  } 
     171 
    164172  void cxios_get_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl, char * time_origin, int time_origin_size) 
    165173  { 
    166      CTimer::get("XIOS").resume(); 
    167     if(!string_copy(calendar_wrapper_hdl->time_origin.getInheritedValue(),time_origin , time_origin_size)) 
    168       ERROR("void cxios_get_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl, char * time_origin, int time_origin_size)", <<"Input string is to short"); 
    169      CTimer::get("XIOS").suspend(); 
    170   } 
    171    
    172   bool cxios_is_defined_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    173   { 
    174      CTimer::get("XIOS").resume(); 
    175     return calendar_wrapper_hdl->time_origin.hasInheritedValue(); 
    176      CTimer::get("XIOS").suspend(); 
    177   } 
    178    
    179    
    180    
     174    CTimer::get("XIOS").resume(); 
     175    if (!string_copy(calendar_wrapper_hdl->time_origin.getInheritedValue(), time_origin, time_origin_size)) 
     176      ERROR("void cxios_get_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl, char * time_origin, int time_origin_size)", << "Input string is too short"); 
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  bool cxios_is_defined_calendar_wrapper_time_origin(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     181  { 
     182     CTimer::get("XIOS").resume(); 
     183     bool isDefined = calendar_wrapper_hdl->time_origin.hasInheritedValue(); 
     184     CTimer::get("XIOS").suspend(); 
     185     return isDefined; 
     186  } 
     187 
     188 
    181189  void cxios_set_calendar_wrapper_timestep(calendar_wrapper_Ptr calendar_wrapper_hdl, cxios_duration timestep_c) 
    182190  { 
    … …  
    193201    CTimer::get("XIOS").suspend(); 
    194202  } 
    195    
     203 
    196204  void cxios_get_calendar_wrapper_timestep(calendar_wrapper_Ptr calendar_wrapper_hdl, cxios_duration* timestep_c) 
    197205  { 
    … …  
    207215    CTimer::get("XIOS").suspend(); 
    208216  } 
    209    
    210   bool cxios_is_defined_calendar_wrapper_timestep(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    211   { 
    212      CTimer::get("XIOS").resume(); 
    213     return calendar_wrapper_hdl->timestep.hasInheritedValue(); 
    214      CTimer::get("XIOS").suspend(); 
    215   } 
    216    
    217    
    218    
     217 
     218  bool cxios_is_defined_calendar_wrapper_timestep(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     219  { 
     220     CTimer::get("XIOS").resume(); 
     221     bool isDefined = calendar_wrapper_hdl->timestep.hasInheritedValue(); 
     222     CTimer::get("XIOS").suspend(); 
     223     return isDefined; 
     224  } 
     225 
     226 
    219227  void cxios_set_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * type, int type_size) 
    220228  { 
    221229    std::string type_str; 
    222     if(!cstr2string(type, type_size, type_str)) return; 
    223      CTimer::get("XIOS").resume(); 
     230    if (!cstr2string(type, type_size, type_str)) return; 
     231    CTimer::get("XIOS").resume(); 
    224232    calendar_wrapper_hdl->type.fromString(type_str); 
    225      CTimer::get("XIOS").suspend(); 
    226   } 
    227    
     233    CTimer::get("XIOS").suspend(); 
     234  } 
     235 
    228236  void cxios_get_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl, char * type, int type_size) 
    229237  { 
    230      CTimer::get("XIOS").resume(); 
    231     if(!string_copy(calendar_wrapper_hdl->type.getInheritedStringValue(),type , type_size)) 
    232       ERROR("void cxios_get_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl, char * type, int type_size)", <<"Input string is to short"); 
    233      CTimer::get("XIOS").suspend(); 
    234   } 
    235    
    236   bool cxios_is_defined_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    237   { 
    238      CTimer::get("XIOS").resume(); 
    239     return calendar_wrapper_hdl->type.hasInheritedValue(); 
    240      CTimer::get("XIOS").suspend(); 
    241   } 
    242    
    243    
    244    
     238    CTimer::get("XIOS").resume(); 
     239    if (!string_copy(calendar_wrapper_hdl->type.getInheritedStringValue(), type, type_size)) 
     240      ERROR("void cxios_get_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl, char * type, int type_size)", << "Input string is too short"); 
     241    CTimer::get("XIOS").suspend(); 
     242  } 
     243 
     244  bool cxios_is_defined_calendar_wrapper_type(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     245  { 
     246     CTimer::get("XIOS").resume(); 
     247     bool isDefined = calendar_wrapper_hdl->type.hasInheritedValue(); 
     248     CTimer::get("XIOS").suspend(); 
     249     return isDefined; 
     250  } 
     251 
     252 
    245253  void cxios_set_calendar_wrapper_year_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int year_length) 
    246254  { 
    247      CTimer::get("XIOS").resume(); 
     255    CTimer::get("XIOS").resume(); 
    248256    calendar_wrapper_hdl->year_length.setValue(year_length); 
    249      CTimer::get("XIOS").suspend(); 
    250   } 
    251    
     257    CTimer::get("XIOS").suspend(); 
     258  } 
     259 
    252260  void cxios_get_calendar_wrapper_year_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int* year_length) 
    253261  { 
     262    CTimer::get("XIOS").resume(); 
    254263    *year_length = calendar_wrapper_hdl->year_length.getInheritedValue(); 
    255   } 
    256    
    257   bool cxios_is_defined_calendar_wrapper_year_length(calendar_wrapper_Ptr calendar_wrapper_hdl ) 
    258   { 
    259      CTimer::get("XIOS").resume(); 
    260     return calendar_wrapper_hdl->year_length.hasInheritedValue(); 
    261      CTimer::get("XIOS").suspend(); 
    262   } 
    263    
    264    
    265    
    266    
     264    CTimer::get("XIOS").suspend(); 
     265  } 
     266 
     267  bool cxios_is_defined_calendar_wrapper_year_length(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     268  { 
     269     CTimer::get("XIOS").resume(); 
     270     bool isDefined = calendar_wrapper_hdl->year_length.hasInheritedValue(); 
     271     CTimer::get("XIOS").suspend(); 
     272     return isDefined; 
     273  } 
    267274} 

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

    r549 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CContext*  context_Ptr; 
    19    
     18  typedef xios::CContext* context_Ptr; 
     19 
    2020  void cxios_set_context_output_dir(context_Ptr context_hdl, const char * output_dir, int output_dir_size) 
    2121  { 
    2222    std::string output_dir_str; 
    23     if(!cstr2string(output_dir, output_dir_size, output_dir_str)) return; 
    24      CTimer::get("XIOS").resume(); 
     23    if (!cstr2string(output_dir, output_dir_size, output_dir_str)) return; 
     24    CTimer::get("XIOS").resume(); 
    2525    context_hdl->output_dir.setValue(output_dir_str); 
    26      CTimer::get("XIOS").suspend(); 
     26    CTimer::get("XIOS").suspend(); 
    2727  } 
    28    
     28 
    2929  void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size) 
    3030  { 
    31      CTimer::get("XIOS").resume(); 
    32     if(!string_copy(context_hdl->output_dir.getInheritedValue(),output_dir , output_dir_size)) 
    33       ERROR("void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)", <<"Input string is to short"); 
    34      CTimer::get("XIOS").suspend(); 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(context_hdl->output_dir.getInheritedValue(), output_dir, output_dir_size)) 
     33      ERROR("void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
    3535  } 
    36    
    37   bool cxios_is_defined_context_output_dir(context_Ptr context_hdl ) 
     36 
     37  bool cxios_is_defined_context_output_dir(context_Ptr context_hdl) 
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return context_hdl->output_dir.hasInheritedValue(); 
     40     bool isDefined = context_hdl->output_dir.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
    4243  } 
    43    
    44    
    45    
    46    
    4744} 

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

    r546 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CDomain*  domain_Ptr; 
    19    
     18  typedef xios::CDomain* domain_Ptr; 
     19 
    2020  void cxios_set_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2) 
    2121  { 
    2222    CTimer::get("XIOS").resume(); 
    23     CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ; 
     23    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    2424    domain_hdl->bounds_lat.reference(tmp.copy()); 
    2525     CTimer::get("XIOS").suspend(); 
    2626  } 
    27    
     27 
    2828  void cxios_get_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2) 
    2929  { 
    3030    CTimer::get("XIOS").resume(); 
    31     CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ; 
    32     tmp=domain_hdl->bounds_lat.getInheritedValue() ; 
    33      CTimer::get("XIOS").suspend(); 
    34   } 
    35    
    36   bool cxios_is_defined_domain_bounds_lat(domain_Ptr domain_hdl ) 
    37   { 
    38      CTimer::get("XIOS").resume(); 
    39     return domain_hdl->bounds_lat.hasInheritedValue(); 
    40      CTimer::get("XIOS").suspend(); 
    41   } 
    42    
    43    
    44    
     31    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
     32    tmp=domain_hdl->bounds_lat.getInheritedValue(); 
     33     CTimer::get("XIOS").suspend(); 
     34  } 
     35 
     36  bool cxios_is_defined_domain_bounds_lat(domain_Ptr domain_hdl) 
     37  { 
     38     CTimer::get("XIOS").resume(); 
     39     bool isDefined = domain_hdl->bounds_lat.hasInheritedValue(); 
     40     CTimer::get("XIOS").suspend(); 
     41     return isDefined; 
     42  } 
     43 
     44 
    4545  void cxios_set_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2) 
    4646  { 
    4747    CTimer::get("XIOS").resume(); 
    48     CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ; 
     48    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    4949    domain_hdl->bounds_lon.reference(tmp.copy()); 
    5050     CTimer::get("XIOS").suspend(); 
    5151  } 
    52    
     52 
    5353  void cxios_get_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2) 
    5454  { 
    5555    CTimer::get("XIOS").resume(); 
    56     CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ; 
    57     tmp=domain_hdl->bounds_lon.getInheritedValue() ; 
    58      CTimer::get("XIOS").suspend(); 
    59   } 
    60    
    61   bool cxios_is_defined_domain_bounds_lon(domain_Ptr domain_hdl ) 
    62   { 
    63      CTimer::get("XIOS").resume(); 
    64     return domain_hdl->bounds_lon.hasInheritedValue(); 
    65      CTimer::get("XIOS").suspend(); 
    66   } 
    67    
    68    
    69    
     56    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
     57    tmp=domain_hdl->bounds_lon.getInheritedValue(); 
     58     CTimer::get("XIOS").suspend(); 
     59  } 
     60 
     61  bool cxios_is_defined_domain_bounds_lon(domain_Ptr domain_hdl) 
     62  { 
     63     CTimer::get("XIOS").resume(); 
     64     bool isDefined = domain_hdl->bounds_lon.hasInheritedValue(); 
     65     CTimer::get("XIOS").suspend(); 
     66     return isDefined; 
     67  } 
     68 
     69 
    7070  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim) 
    7171  { 
    72      CTimer::get("XIOS").resume(); 
     72    CTimer::get("XIOS").resume(); 
    7373    domain_hdl->data_dim.setValue(data_dim); 
    74      CTimer::get("XIOS").suspend(); 
    75   } 
    76    
     74    CTimer::get("XIOS").suspend(); 
     75  } 
     76 
    7777  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim) 
    7878  { 
     79    CTimer::get("XIOS").resume(); 
    7980    *data_dim = domain_hdl->data_dim.getInheritedValue(); 
    80   } 
    81    
    82   bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl ) 
    83   { 
    84      CTimer::get("XIOS").resume(); 
    85     return domain_hdl->data_dim.hasInheritedValue(); 
    86      CTimer::get("XIOS").suspend(); 
    87   } 
    88    
    89    
    90    
     81    CTimer::get("XIOS").suspend(); 
     82  } 
     83 
     84  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl) 
     85  { 
     86     CTimer::get("XIOS").resume(); 
     87     bool isDefined = domain_hdl->data_dim.hasInheritedValue(); 
     88     CTimer::get("XIOS").suspend(); 
     89     return isDefined; 
     90  } 
     91 
     92 
    9193  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1) 
    9294  { 
    9395    CTimer::get("XIOS").resume(); 
    94     CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     96    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData); 
    9597    domain_hdl->data_i_index.reference(tmp.copy()); 
    9698     CTimer::get("XIOS").suspend(); 
    9799  } 
    98    
     100 
    99101  void cxios_get_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1) 
    100102  { 
    101103    CTimer::get("XIOS").resume(); 
    102     CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
    103     tmp=domain_hdl->data_i_index.getInheritedValue() ; 
    104      CTimer::get("XIOS").suspend(); 
    105   } 
    106    
    107   bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl ) 
    108   { 
    109      CTimer::get("XIOS").resume(); 
    110     return domain_hdl->data_i_index.hasInheritedValue(); 
    111      CTimer::get("XIOS").suspend(); 
    112   } 
    113    
    114    
    115    
     104    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData); 
     105    tmp=domain_hdl->data_i_index.getInheritedValue(); 
     106     CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = domain_hdl->data_i_index.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    116118  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin) 
    117119  { 
    118      CTimer::get("XIOS").resume(); 
     120    CTimer::get("XIOS").resume(); 
    119121    domain_hdl->data_ibegin.setValue(data_ibegin); 
    120      CTimer::get("XIOS").suspend(); 
    121   } 
    122    
     122    CTimer::get("XIOS").suspend(); 
     123  } 
     124 
    123125  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin) 
    124126  { 
     127    CTimer::get("XIOS").resume(); 
    125128    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue(); 
    126   } 
    127    
    128   bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl ) 
    129   { 
    130      CTimer::get("XIOS").resume(); 
    131     return domain_hdl->data_ibegin.hasInheritedValue(); 
    132      CTimer::get("XIOS").suspend(); 
    133   } 
    134    
    135    
    136    
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = domain_hdl->data_ibegin.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    137141  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1) 
    138142  { 
    139143    CTimer::get("XIOS").resume(); 
    140     CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     144    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData); 
    141145    domain_hdl->data_j_index.reference(tmp.copy()); 
    142146     CTimer::get("XIOS").suspend(); 
    143147  } 
    144    
     148 
    145149  void cxios_get_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1) 
    146150  { 
    147151    CTimer::get("XIOS").resume(); 
    148     CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
    149     tmp=domain_hdl->data_j_index.getInheritedValue() ; 
    150      CTimer::get("XIOS").suspend(); 
    151   } 
    152    
    153   bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl ) 
    154   { 
    155      CTimer::get("XIOS").resume(); 
    156     return domain_hdl->data_j_index.hasInheritedValue(); 
    157      CTimer::get("XIOS").suspend(); 
    158   } 
    159    
    160    
    161    
     152    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData); 
     153    tmp=domain_hdl->data_j_index.getInheritedValue(); 
     154     CTimer::get("XIOS").suspend(); 
     155  } 
     156 
     157  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl) 
     158  { 
     159     CTimer::get("XIOS").resume(); 
     160     bool isDefined = domain_hdl->data_j_index.hasInheritedValue(); 
     161     CTimer::get("XIOS").suspend(); 
     162     return isDefined; 
     163  } 
     164 
     165 
    162166  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin) 
    163167  { 
    164      CTimer::get("XIOS").resume(); 
     168    CTimer::get("XIOS").resume(); 
    165169    domain_hdl->data_jbegin.setValue(data_jbegin); 
    166      CTimer::get("XIOS").suspend(); 
    167   } 
    168    
     170    CTimer::get("XIOS").suspend(); 
     171  } 
     172 
    169173  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin) 
    170174  { 
     175    CTimer::get("XIOS").resume(); 
    171176    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue(); 
    172   } 
    173    
    174   bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl ) 
    175   { 
    176      CTimer::get("XIOS").resume(); 
    177     return domain_hdl->data_jbegin.hasInheritedValue(); 
    178      CTimer::get("XIOS").suspend(); 
    179   } 
    180    
    181    
    182    
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl) 
     181  { 
     182     CTimer::get("XIOS").resume(); 
     183     bool isDefined = domain_hdl->data_jbegin.hasInheritedValue(); 
     184     CTimer::get("XIOS").suspend(); 
     185     return isDefined; 
     186  } 
     187 
     188 
    183189  void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index) 
    184190  { 
    185      CTimer::get("XIOS").resume(); 
     191    CTimer::get("XIOS").resume(); 
    186192    domain_hdl->data_n_index.setValue(data_n_index); 
    187      CTimer::get("XIOS").suspend(); 
    188   } 
    189    
     193    CTimer::get("XIOS").suspend(); 
     194  } 
     195 
    190196  void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index) 
    191197  { 
     198    CTimer::get("XIOS").resume(); 
    192199    *data_n_index = domain_hdl->data_n_index.getInheritedValue(); 
    193   } 
    194    
    195   bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl ) 
    196   { 
    197      CTimer::get("XIOS").resume(); 
    198     return domain_hdl->data_n_index.hasInheritedValue(); 
    199      CTimer::get("XIOS").suspend(); 
    200   } 
    201    
    202    
    203    
     200    CTimer::get("XIOS").suspend(); 
     201  } 
     202 
     203  bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl) 
     204  { 
     205     CTimer::get("XIOS").resume(); 
     206     bool isDefined = domain_hdl->data_n_index.hasInheritedValue(); 
     207     CTimer::get("XIOS").suspend(); 
     208     return isDefined; 
     209  } 
     210 
     211 
    204212  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni) 
    205213  { 
    206      CTimer::get("XIOS").resume(); 
     214    CTimer::get("XIOS").resume(); 
    207215    domain_hdl->data_ni.setValue(data_ni); 
    208      CTimer::get("XIOS").suspend(); 
    209   } 
    210    
     216    CTimer::get("XIOS").suspend(); 
     217  } 
     218 
    211219  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni) 
    212220  { 
     221    CTimer::get("XIOS").resume(); 
    213222    *data_ni = domain_hdl->data_ni.getInheritedValue(); 
    214   } 
    215    
    216   bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl ) 
    217   { 
    218      CTimer::get("XIOS").resume(); 
    219     return domain_hdl->data_ni.hasInheritedValue(); 
    220      CTimer::get("XIOS").suspend(); 
    221   } 
    222    
    223    
    224    
     223    CTimer::get("XIOS").suspend(); 
     224  } 
     225 
     226  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl) 
     227  { 
     228     CTimer::get("XIOS").resume(); 
     229     bool isDefined = domain_hdl->data_ni.hasInheritedValue(); 
     230     CTimer::get("XIOS").suspend(); 
     231     return isDefined; 
     232  } 
     233 
     234 
    225235  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj) 
    226236  { 
    227      CTimer::get("XIOS").resume(); 
     237    CTimer::get("XIOS").resume(); 
    228238    domain_hdl->data_nj.setValue(data_nj); 
    229      CTimer::get("XIOS").suspend(); 
    230   } 
    231    
     239    CTimer::get("XIOS").suspend(); 
     240  } 
     241 
    232242  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj) 
    233243  { 
     244    CTimer::get("XIOS").resume(); 
    234245    *data_nj = domain_hdl->data_nj.getInheritedValue(); 
    235   } 
    236    
    237   bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl ) 
    238   { 
    239      CTimer::get("XIOS").resume(); 
    240     return domain_hdl->data_nj.hasInheritedValue(); 
    241      CTimer::get("XIOS").suspend(); 
    242   } 
    243    
    244    
    245    
     246    CTimer::get("XIOS").suspend(); 
     247  } 
     248 
     249  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl) 
     250  { 
     251     CTimer::get("XIOS").resume(); 
     252     bool isDefined = domain_hdl->data_nj.hasInheritedValue(); 
     253     CTimer::get("XIOS").suspend(); 
     254     return isDefined; 
     255  } 
     256 
     257 
    246258  void cxios_set_domain_domain_group_ref(domain_Ptr domain_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    247259  { 
    248260    std::string domain_group_ref_str; 
    249     if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
    250      CTimer::get("XIOS").resume(); 
     261    if (!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
     262    CTimer::get("XIOS").resume(); 
    251263    domain_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    252      CTimer::get("XIOS").suspend(); 
    253   } 
    254    
     264    CTimer::get("XIOS").suspend(); 
     265  } 
     266 
    255267  void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size) 
    256268  { 
    257      CTimer::get("XIOS").resume(); 
    258     if(!string_copy(domain_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size)) 
    259       ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
    260      CTimer::get("XIOS").suspend(); 
    261   } 
    262    
    263   bool cxios_is_defined_domain_domain_group_ref(domain_Ptr domain_hdl ) 
    264   { 
    265      CTimer::get("XIOS").resume(); 
    266     return domain_hdl->domain_group_ref.hasInheritedValue(); 
    267      CTimer::get("XIOS").suspend(); 
    268   } 
    269    
    270    
    271    
     269    CTimer::get("XIOS").resume(); 
     270    if (!string_copy(domain_hdl->domain_group_ref.getInheritedValue(), domain_group_ref, domain_group_ref_size)) 
     271      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", << "Input string is too short"); 
     272    CTimer::get("XIOS").suspend(); 
     273  } 
     274 
     275  bool cxios_is_defined_domain_domain_group_ref(domain_Ptr domain_hdl) 
     276  { 
     277     CTimer::get("XIOS").resume(); 
     278     bool isDefined = domain_hdl->domain_group_ref.hasInheritedValue(); 
     279     CTimer::get("XIOS").suspend(); 
     280     return isDefined; 
     281  } 
     282 
     283 
    272284  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size) 
    273285  { 
    274286    std::string domain_ref_str; 
    275     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    276      CTimer::get("XIOS").resume(); 
     287    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     288    CTimer::get("XIOS").resume(); 
    277289    domain_hdl->domain_ref.setValue(domain_ref_str); 
    278      CTimer::get("XIOS").suspend(); 
    279   } 
    280    
     290    CTimer::get("XIOS").suspend(); 
     291  } 
     292 
    281293  void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size) 
    282294  { 
    283      CTimer::get("XIOS").resume(); 
    284     if(!string_copy(domain_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    285       ERROR("void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    286      CTimer::get("XIOS").suspend(); 
    287   } 
    288    
    289   bool cxios_is_defined_domain_domain_ref(domain_Ptr domain_hdl ) 
    290   { 
    291      CTimer::get("XIOS").resume(); 
    292     return domain_hdl->domain_ref.hasInheritedValue(); 
    293      CTimer::get("XIOS").suspend(); 
    294   } 
    295    
    296    
    297    
     295    CTimer::get("XIOS").resume(); 
     296    if (!string_copy(domain_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size)) 
     297      ERROR("void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short"); 
     298    CTimer::get("XIOS").suspend(); 
     299  } 
     300 
     301  bool cxios_is_defined_domain_domain_ref(domain_Ptr domain_hdl) 
     302  { 
     303     CTimer::get("XIOS").resume(); 
     304     bool isDefined = domain_hdl->domain_ref.hasInheritedValue(); 
     305     CTimer::get("XIOS").suspend(); 
     306     return isDefined; 
     307  } 
     308 
     309 
    298310  void cxios_set_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1, int extent2) 
    299311  { 
    300312    CTimer::get("XIOS").resume(); 
    301     CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ; 
     313    CArray<int,2> tmp(i_index, shape(extent1, extent2), neverDeleteData); 
    302314    domain_hdl->i_index.reference(tmp.copy()); 
    303315     CTimer::get("XIOS").suspend(); 
    304316  } 
    305    
     317 
    306318  void cxios_get_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1, int extent2) 
    307319  { 
    308320    CTimer::get("XIOS").resume(); 
    309     CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ; 
    310     tmp=domain_hdl->i_index.getInheritedValue() ; 
    311      CTimer::get("XIOS").suspend(); 
    312   } 
    313    
    314   bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl ) 
    315   { 
    316      CTimer::get("XIOS").resume(); 
    317     return domain_hdl->i_index.hasInheritedValue(); 
    318      CTimer::get("XIOS").suspend(); 
    319   } 
    320    
    321    
    322    
     321    CArray<int,2> tmp(i_index, shape(extent1, extent2), neverDeleteData); 
     322    tmp=domain_hdl->i_index.getInheritedValue(); 
     323     CTimer::get("XIOS").suspend(); 
     324  } 
     325 
     326  bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl) 
     327  { 
     328     CTimer::get("XIOS").resume(); 
     329     bool isDefined = domain_hdl->i_index.hasInheritedValue(); 
     330     CTimer::get("XIOS").suspend(); 
     331     return isDefined; 
     332  } 
     333 
     334 
    323335  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin) 
    324336  { 
    325      CTimer::get("XIOS").resume(); 
     337    CTimer::get("XIOS").resume(); 
    326338    domain_hdl->ibegin.setValue(ibegin); 
    327      CTimer::get("XIOS").suspend(); 
    328   } 
    329    
     339    CTimer::get("XIOS").suspend(); 
     340  } 
     341 
    330342  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin) 
    331343  { 
     344    CTimer::get("XIOS").resume(); 
    332345    *ibegin = domain_hdl->ibegin.getInheritedValue(); 
    333   } 
    334    
    335   bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl ) 
    336   { 
    337      CTimer::get("XIOS").resume(); 
    338     return domain_hdl->ibegin.hasInheritedValue(); 
    339      CTimer::get("XIOS").suspend(); 
    340   } 
    341    
    342    
    343    
     346    CTimer::get("XIOS").suspend(); 
     347  } 
     348 
     349  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl) 
     350  { 
     351     CTimer::get("XIOS").resume(); 
     352     bool isDefined = domain_hdl->ibegin.hasInheritedValue(); 
     353     CTimer::get("XIOS").suspend(); 
     354     return isDefined; 
     355  } 
     356 
     357 
    344358  void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend) 
    345359  { 
    346      CTimer::get("XIOS").resume(); 
     360    CTimer::get("XIOS").resume(); 
    347361    domain_hdl->iend.setValue(iend); 
    348      CTimer::get("XIOS").suspend(); 
    349   } 
    350    
     362    CTimer::get("XIOS").suspend(); 
     363  } 
     364 
    351365  void cxios_get_domain_iend(domain_Ptr domain_hdl, int* iend) 
    352366  { 
     367    CTimer::get("XIOS").resume(); 
    353368    *iend = domain_hdl->iend.getInheritedValue(); 
    354   } 
    355    
    356   bool cxios_is_defined_domain_iend(domain_Ptr domain_hdl ) 
    357   { 
    358      CTimer::get("XIOS").resume(); 
    359     return domain_hdl->iend.hasInheritedValue(); 
    360      CTimer::get("XIOS").suspend(); 
    361   } 
    362    
    363    
    364    
     369    CTimer::get("XIOS").suspend(); 
     370  } 
     371 
     372  bool cxios_is_defined_domain_iend(domain_Ptr domain_hdl) 
     373  { 
     374     CTimer::get("XIOS").resume(); 
     375     bool isDefined = domain_hdl->iend.hasInheritedValue(); 
     376     CTimer::get("XIOS").suspend(); 
     377     return isDefined; 
     378  } 
     379 
     380 
    365381  void cxios_set_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1, int extent2) 
    366382  { 
    367383    CTimer::get("XIOS").resume(); 
    368     CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ; 
     384    CArray<int,2> tmp(j_index, shape(extent1, extent2), neverDeleteData); 
    369385    domain_hdl->j_index.reference(tmp.copy()); 
    370386     CTimer::get("XIOS").suspend(); 
    371387  } 
    372    
     388 
    373389  void cxios_get_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1, int extent2) 
    374390  { 
    375391    CTimer::get("XIOS").resume(); 
    376     CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ; 
    377     tmp=domain_hdl->j_index.getInheritedValue() ; 
    378      CTimer::get("XIOS").suspend(); 
    379   } 
    380    
    381   bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl ) 
    382   { 
    383      CTimer::get("XIOS").resume(); 
    384     return domain_hdl->j_index.hasInheritedValue(); 
    385      CTimer::get("XIOS").suspend(); 
    386   } 
    387    
    388    
    389    
     392    CArray<int,2> tmp(j_index, shape(extent1, extent2), neverDeleteData); 
     393    tmp=domain_hdl->j_index.getInheritedValue(); 
     394     CTimer::get("XIOS").suspend(); 
     395  } 
     396 
     397  bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl) 
     398  { 
     399     CTimer::get("XIOS").resume(); 
     400     bool isDefined = domain_hdl->j_index.hasInheritedValue(); 
     401     CTimer::get("XIOS").suspend(); 
     402     return isDefined; 
     403  } 
     404 
     405 
    390406  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin) 
    391407  { 
    392      CTimer::get("XIOS").resume(); 
     408    CTimer::get("XIOS").resume(); 
    393409    domain_hdl->jbegin.setValue(jbegin); 
    394      CTimer::get("XIOS").suspend(); 
    395   } 
    396    
     410    CTimer::get("XIOS").suspend(); 
     411  } 
     412 
    397413  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin) 
    398414  { 
     415    CTimer::get("XIOS").resume(); 
    399416    *jbegin = domain_hdl->jbegin.getInheritedValue(); 
    400   } 
    401    
    402   bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl ) 
    403   { 
    404      CTimer::get("XIOS").resume(); 
    405     return domain_hdl->jbegin.hasInheritedValue(); 
    406      CTimer::get("XIOS").suspend(); 
    407   } 
    408    
    409    
    410    
     417    CTimer::get("XIOS").suspend(); 
     418  } 
     419 
     420  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl) 
     421  { 
     422     CTimer::get("XIOS").resume(); 
     423     bool isDefined = domain_hdl->jbegin.hasInheritedValue(); 
     424     CTimer::get("XIOS").suspend(); 
     425     return isDefined; 
     426  } 
     427 
     428 
    411429  void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend) 
    412430  { 
    413      CTimer::get("XIOS").resume(); 
     431    CTimer::get("XIOS").resume(); 
    414432    domain_hdl->jend.setValue(jend); 
    415      CTimer::get("XIOS").suspend(); 
    416   } 
    417    
     433    CTimer::get("XIOS").suspend(); 
     434  } 
     435 
    418436  void cxios_get_domain_jend(domain_Ptr domain_hdl, int* jend) 
    419437  { 
     438    CTimer::get("XIOS").resume(); 
    420439    *jend = domain_hdl->jend.getInheritedValue(); 
    421   } 
    422    
    423   bool cxios_is_defined_domain_jend(domain_Ptr domain_hdl ) 
    424   { 
    425      CTimer::get("XIOS").resume(); 
    426     return domain_hdl->jend.hasInheritedValue(); 
    427      CTimer::get("XIOS").suspend(); 
    428   } 
    429    
    430    
    431    
     440    CTimer::get("XIOS").suspend(); 
     441  } 
     442 
     443  bool cxios_is_defined_domain_jend(domain_Ptr domain_hdl) 
     444  { 
     445     CTimer::get("XIOS").resume(); 
     446     bool isDefined = domain_hdl->jend.hasInheritedValue(); 
     447     CTimer::get("XIOS").suspend(); 
     448     return isDefined; 
     449  } 
     450 
     451 
    432452  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    433453  { 
    434454    CTimer::get("XIOS").resume(); 
    435     CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     455    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    436456    domain_hdl->latvalue.reference(tmp.copy()); 
    437457     CTimer::get("XIOS").suspend(); 
    438458  } 
    439    
     459 
    440460  void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    441461  { 
    442462    CTimer::get("XIOS").resume(); 
    443     CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
    444     tmp=domain_hdl->latvalue.getInheritedValue() ; 
    445      CTimer::get("XIOS").suspend(); 
    446   } 
    447    
    448   bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl ) 
    449   { 
    450      CTimer::get("XIOS").resume(); 
    451     return domain_hdl->latvalue.hasInheritedValue(); 
    452      CTimer::get("XIOS").suspend(); 
    453   } 
    454    
    455    
    456    
     463    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
     464    tmp=domain_hdl->latvalue.getInheritedValue(); 
     465     CTimer::get("XIOS").suspend(); 
     466  } 
     467 
     468  bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl) 
     469  { 
     470     CTimer::get("XIOS").resume(); 
     471     bool isDefined = domain_hdl->latvalue.hasInheritedValue(); 
     472     CTimer::get("XIOS").suspend(); 
     473     return isDefined; 
     474  } 
     475 
     476 
    457477  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size) 
    458478  { 
    459479    std::string long_name_str; 
    460     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    461      CTimer::get("XIOS").resume(); 
     480    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     481    CTimer::get("XIOS").resume(); 
    462482    domain_hdl->long_name.setValue(long_name_str); 
    463      CTimer::get("XIOS").suspend(); 
    464   } 
    465    
     483    CTimer::get("XIOS").suspend(); 
     484  } 
     485 
    466486  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size) 
    467487  { 
    468      CTimer::get("XIOS").resume(); 
    469     if(!string_copy(domain_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    470       ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    471      CTimer::get("XIOS").suspend(); 
    472   } 
    473    
    474   bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl ) 
    475   { 
    476      CTimer::get("XIOS").resume(); 
    477     return domain_hdl->long_name.hasInheritedValue(); 
    478      CTimer::get("XIOS").suspend(); 
    479   } 
    480    
    481    
    482    
     488    CTimer::get("XIOS").resume(); 
     489    if (!string_copy(domain_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     490      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     491    CTimer::get("XIOS").suspend(); 
     492  } 
     493 
     494  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl) 
     495  { 
     496     CTimer::get("XIOS").resume(); 
     497     bool isDefined = domain_hdl->long_name.hasInheritedValue(); 
     498     CTimer::get("XIOS").suspend(); 
     499     return isDefined; 
     500  } 
     501 
     502 
    483503  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    484504  { 
    485505    CTimer::get("XIOS").resume(); 
    486     CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     506    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    487507    domain_hdl->lonvalue.reference(tmp.copy()); 
    488508     CTimer::get("XIOS").suspend(); 
    489509  } 
    490    
     510 
    491511  void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    492512  { 
    493513    CTimer::get("XIOS").resume(); 
    494     CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
    495     tmp=domain_hdl->lonvalue.getInheritedValue() ; 
    496      CTimer::get("XIOS").suspend(); 
    497   } 
    498    
    499   bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl ) 
    500   { 
    501      CTimer::get("XIOS").resume(); 
    502     return domain_hdl->lonvalue.hasInheritedValue(); 
    503      CTimer::get("XIOS").suspend(); 
    504   } 
    505    
    506    
    507    
     514    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
     515    tmp=domain_hdl->lonvalue.getInheritedValue(); 
     516     CTimer::get("XIOS").suspend(); 
     517  } 
     518 
     519  bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl) 
     520  { 
     521     CTimer::get("XIOS").resume(); 
     522     bool isDefined = domain_hdl->lonvalue.hasInheritedValue(); 
     523     CTimer::get("XIOS").suspend(); 
     524     return isDefined; 
     525  } 
     526 
     527 
    508528  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    509529  { 
    510530    CTimer::get("XIOS").resume(); 
    511     CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     531    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    512532    domain_hdl->mask.reference(tmp.copy()); 
    513533     CTimer::get("XIOS").suspend(); 
    514534  } 
    515    
     535 
    516536  void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    517537  { 
    518538    CTimer::get("XIOS").resume(); 
    519     CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
    520     tmp=domain_hdl->mask.getInheritedValue() ; 
    521      CTimer::get("XIOS").suspend(); 
    522   } 
    523    
    524   bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl ) 
    525   { 
    526      CTimer::get("XIOS").resume(); 
    527     return domain_hdl->mask.hasInheritedValue(); 
    528      CTimer::get("XIOS").suspend(); 
    529   } 
    530    
    531    
    532    
     539    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
     540    tmp=domain_hdl->mask.getInheritedValue(); 
     541     CTimer::get("XIOS").suspend(); 
     542  } 
     543 
     544  bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl) 
     545  { 
     546     CTimer::get("XIOS").resume(); 
     547     bool isDefined = domain_hdl->mask.hasInheritedValue(); 
     548     CTimer::get("XIOS").suspend(); 
     549     return isDefined; 
     550  } 
     551 
     552 
    533553  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size) 
    534554  { 
    535555    std::string name_str; 
    536     if(!cstr2string(name, name_size, name_str)) return; 
    537      CTimer::get("XIOS").resume(); 
     556    if (!cstr2string(name, name_size, name_str)) return; 
     557    CTimer::get("XIOS").resume(); 
    538558    domain_hdl->name.setValue(name_str); 
    539      CTimer::get("XIOS").suspend(); 
    540   } 
    541    
     559    CTimer::get("XIOS").suspend(); 
     560  } 
     561 
    542562  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size) 
    543563  { 
    544      CTimer::get("XIOS").resume(); 
    545     if(!string_copy(domain_hdl->name.getInheritedValue(),name , name_size)) 
    546       ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short"); 
    547      CTimer::get("XIOS").suspend(); 
    548   } 
    549    
    550   bool cxios_is_defined_domain_name(domain_Ptr domain_hdl ) 
    551   { 
    552      CTimer::get("XIOS").resume(); 
    553     return domain_hdl->name.hasInheritedValue(); 
    554      CTimer::get("XIOS").suspend(); 
    555   } 
    556    
    557    
    558    
     564    CTimer::get("XIOS").resume(); 
     565    if (!string_copy(domain_hdl->name.getInheritedValue(), name, name_size)) 
     566      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", << "Input string is too short"); 
     567    CTimer::get("XIOS").suspend(); 
     568  } 
     569 
     570  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl) 
     571  { 
     572     CTimer::get("XIOS").resume(); 
     573     bool isDefined = domain_hdl->name.hasInheritedValue(); 
     574     CTimer::get("XIOS").suspend(); 
     575     return isDefined; 
     576  } 
     577 
     578 
    559579  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni) 
    560580  { 
    561      CTimer::get("XIOS").resume(); 
     581    CTimer::get("XIOS").resume(); 
    562582    domain_hdl->ni.setValue(ni); 
    563      CTimer::get("XIOS").suspend(); 
    564   } 
    565    
     583    CTimer::get("XIOS").suspend(); 
     584  } 
     585 
    566586  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni) 
    567587  { 
     588    CTimer::get("XIOS").resume(); 
    568589    *ni = domain_hdl->ni.getInheritedValue(); 
    569   } 
    570    
    571   bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl ) 
    572   { 
    573      CTimer::get("XIOS").resume(); 
    574     return domain_hdl->ni.hasInheritedValue(); 
    575      CTimer::get("XIOS").suspend(); 
    576   } 
    577    
    578    
    579    
     590    CTimer::get("XIOS").suspend(); 
     591  } 
     592 
     593  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl) 
     594  { 
     595     CTimer::get("XIOS").resume(); 
     596     bool isDefined = domain_hdl->ni.hasInheritedValue(); 
     597     CTimer::get("XIOS").suspend(); 
     598     return isDefined; 
     599  } 
     600 
     601 
    580602  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo) 
    581603  { 
    582      CTimer::get("XIOS").resume(); 
     604    CTimer::get("XIOS").resume(); 
    583605    domain_hdl->ni_glo.setValue(ni_glo); 
    584      CTimer::get("XIOS").suspend(); 
    585   } 
    586    
     606    CTimer::get("XIOS").suspend(); 
     607  } 
     608 
    587609  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo) 
    588610  { 
     611    CTimer::get("XIOS").resume(); 
    589612    *ni_glo = domain_hdl->ni_glo.getInheritedValue(); 
    590   } 
    591    
    592   bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl ) 
    593   { 
    594      CTimer::get("XIOS").resume(); 
    595     return domain_hdl->ni_glo.hasInheritedValue(); 
    596      CTimer::get("XIOS").suspend(); 
    597   } 
    598    
    599    
    600    
     613    CTimer::get("XIOS").suspend(); 
     614  } 
     615 
     616  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl) 
     617  { 
     618     CTimer::get("XIOS").resume(); 
     619     bool isDefined = domain_hdl->ni_glo.hasInheritedValue(); 
     620     CTimer::get("XIOS").suspend(); 
     621     return isDefined; 
     622  } 
     623 
     624 
    601625  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj) 
    602626  { 
    603      CTimer::get("XIOS").resume(); 
     627    CTimer::get("XIOS").resume(); 
    604628    domain_hdl->nj.setValue(nj); 
    605      CTimer::get("XIOS").suspend(); 
    606   } 
    607    
     629    CTimer::get("XIOS").suspend(); 
     630  } 
     631 
    608632  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj) 
    609633  { 
     634    CTimer::get("XIOS").resume(); 
    610635    *nj = domain_hdl->nj.getInheritedValue(); 
    611   } 
    612    
    613   bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl ) 
    614   { 
    615      CTimer::get("XIOS").resume(); 
    616     return domain_hdl->nj.hasInheritedValue(); 
    617      CTimer::get("XIOS").suspend(); 
    618   } 
    619    
    620    
    621    
     636    CTimer::get("XIOS").suspend(); 
     637  } 
     638 
     639  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl) 
     640  { 
     641     CTimer::get("XIOS").resume(); 
     642     bool isDefined = domain_hdl->nj.hasInheritedValue(); 
     643     CTimer::get("XIOS").suspend(); 
     644     return isDefined; 
     645  } 
     646 
     647 
    622648  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo) 
    623649  { 
    624      CTimer::get("XIOS").resume(); 
     650    CTimer::get("XIOS").resume(); 
    625651    domain_hdl->nj_glo.setValue(nj_glo); 
    626      CTimer::get("XIOS").suspend(); 
    627   } 
    628    
     652    CTimer::get("XIOS").suspend(); 
     653  } 
     654 
    629655  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo) 
    630656  { 
     657    CTimer::get("XIOS").resume(); 
    631658    *nj_glo = domain_hdl->nj_glo.getInheritedValue(); 
    632   } 
    633    
    634   bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl ) 
    635   { 
    636      CTimer::get("XIOS").resume(); 
    637     return domain_hdl->nj_glo.hasInheritedValue(); 
    638      CTimer::get("XIOS").suspend(); 
    639   } 
    640    
    641    
    642    
     659    CTimer::get("XIOS").suspend(); 
     660  } 
     661 
     662  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl) 
     663  { 
     664     CTimer::get("XIOS").resume(); 
     665     bool isDefined = domain_hdl->nj_glo.hasInheritedValue(); 
     666     CTimer::get("XIOS").suspend(); 
     667     return isDefined; 
     668  } 
     669 
     670 
    643671  void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex) 
    644672  { 
    645      CTimer::get("XIOS").resume(); 
     673    CTimer::get("XIOS").resume(); 
    646674    domain_hdl->nvertex.setValue(nvertex); 
    647      CTimer::get("XIOS").suspend(); 
    648   } 
    649    
     675    CTimer::get("XIOS").suspend(); 
     676  } 
     677 
    650678  void cxios_get_domain_nvertex(domain_Ptr domain_hdl, int* nvertex) 
    651679  { 
     680    CTimer::get("XIOS").resume(); 
    652681    *nvertex = domain_hdl->nvertex.getInheritedValue(); 
    653   } 
    654    
    655   bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl ) 
    656   { 
    657      CTimer::get("XIOS").resume(); 
    658     return domain_hdl->nvertex.hasInheritedValue(); 
    659      CTimer::get("XIOS").suspend(); 
    660   } 
    661    
    662    
    663    
     682    CTimer::get("XIOS").suspend(); 
     683  } 
     684 
     685  bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl) 
     686  { 
     687     CTimer::get("XIOS").resume(); 
     688     bool isDefined = domain_hdl->nvertex.hasInheritedValue(); 
     689     CTimer::get("XIOS").suspend(); 
     690     return isDefined; 
     691  } 
     692 
     693 
    664694  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size) 
    665695  { 
    666696    std::string standard_name_str; 
    667     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    668      CTimer::get("XIOS").resume(); 
     697    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     698    CTimer::get("XIOS").resume(); 
    669699    domain_hdl->standard_name.setValue(standard_name_str); 
    670      CTimer::get("XIOS").suspend(); 
    671   } 
    672    
     700    CTimer::get("XIOS").suspend(); 
     701  } 
     702 
    673703  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size) 
    674704  { 
    675      CTimer::get("XIOS").resume(); 
    676     if(!string_copy(domain_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    677       ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    678      CTimer::get("XIOS").suspend(); 
    679   } 
    680    
    681   bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl ) 
    682   { 
    683      CTimer::get("XIOS").resume(); 
    684     return domain_hdl->standard_name.hasInheritedValue(); 
    685      CTimer::get("XIOS").suspend(); 
    686   } 
    687    
    688    
    689    
     705    CTimer::get("XIOS").resume(); 
     706    if (!string_copy(domain_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     707      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     708    CTimer::get("XIOS").suspend(); 
     709  } 
     710 
     711  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl) 
     712  { 
     713     CTimer::get("XIOS").resume(); 
     714     bool isDefined = domain_hdl->standard_name.hasInheritedValue(); 
     715     CTimer::get("XIOS").suspend(); 
     716     return isDefined; 
     717  } 
     718 
     719 
    690720  void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size) 
    691721  { 
    692722    std::string type_str; 
    693     if(!cstr2string(type, type_size, type_str)) return; 
    694      CTimer::get("XIOS").resume(); 
     723    if (!cstr2string(type, type_size, type_str)) return; 
     724    CTimer::get("XIOS").resume(); 
    695725    domain_hdl->type.fromString(type_str); 
    696      CTimer::get("XIOS").suspend(); 
    697   } 
    698    
     726    CTimer::get("XIOS").suspend(); 
     727  } 
     728 
    699729  void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size) 
    700730  { 
    701      CTimer::get("XIOS").resume(); 
    702     if(!string_copy(domain_hdl->type.getInheritedStringValue(),type , type_size)) 
    703       ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", <<"Input string is to short"); 
    704      CTimer::get("XIOS").suspend(); 
    705   } 
    706    
    707   bool cxios_is_defined_domain_type(domain_Ptr domain_hdl ) 
    708   { 
    709      CTimer::get("XIOS").resume(); 
    710     return domain_hdl->type.hasInheritedValue(); 
    711      CTimer::get("XIOS").suspend(); 
    712   } 
    713    
    714    
    715    
     731    CTimer::get("XIOS").resume(); 
     732    if (!string_copy(domain_hdl->type.getInheritedStringValue(), type, type_size)) 
     733      ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", << "Input string is too short"); 
     734    CTimer::get("XIOS").suspend(); 
     735  } 
     736 
     737  bool cxios_is_defined_domain_type(domain_Ptr domain_hdl) 
     738  { 
     739     CTimer::get("XIOS").resume(); 
     740     bool isDefined = domain_hdl->type.hasInheritedValue(); 
     741     CTimer::get("XIOS").suspend(); 
     742     return isDefined; 
     743  } 
     744 
     745 
    716746  void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin) 
    717747  { 
    718      CTimer::get("XIOS").resume(); 
     748    CTimer::get("XIOS").resume(); 
    719749    domain_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    720      CTimer::get("XIOS").suspend(); 
    721   } 
    722    
     750    CTimer::get("XIOS").suspend(); 
     751  } 
     752 
    723753  void cxios_get_domain_zoom_ibegin(domain_Ptr domain_hdl, int* zoom_ibegin) 
    724754  { 
     755    CTimer::get("XIOS").resume(); 
    725756    *zoom_ibegin = domain_hdl->zoom_ibegin.getInheritedValue(); 
    726   } 
    727    
    728   bool cxios_is_defined_domain_zoom_ibegin(domain_Ptr domain_hdl ) 
    729   { 
    730      CTimer::get("XIOS").resume(); 
    731     return domain_hdl->zoom_ibegin.hasInheritedValue(); 
    732      CTimer::get("XIOS").suspend(); 
    733   } 
    734    
    735    
    736    
     757    CTimer::get("XIOS").suspend(); 
     758  } 
     759 
     760  bool cxios_is_defined_domain_zoom_ibegin(domain_Ptr domain_hdl) 
     761  { 
     762     CTimer::get("XIOS").resume(); 
     763     bool isDefined = domain_hdl->zoom_ibegin.hasInheritedValue(); 
     764     CTimer::get("XIOS").suspend(); 
     765     return isDefined; 
     766  } 
     767 
     768 
    737769  void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc) 
    738770  { 
    739      CTimer::get("XIOS").resume(); 
     771    CTimer::get("XIOS").resume(); 
    740772    domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    741      CTimer::get("XIOS").suspend(); 
    742   } 
    743    
     773    CTimer::get("XIOS").suspend(); 
     774  } 
     775 
    744776  void cxios_get_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int* zoom_ibegin_loc) 
    745777  { 
     778    CTimer::get("XIOS").resume(); 
    746779    *zoom_ibegin_loc = domain_hdl->zoom_ibegin_loc.getInheritedValue(); 
    747   } 
    748    
    749   bool cxios_is_defined_domain_zoom_ibegin_loc(domain_Ptr domain_hdl ) 
    750   { 
    751      CTimer::get("XIOS").resume(); 
    752     return domain_hdl->zoom_ibegin_loc.hasInheritedValue(); 
    753      CTimer::get("XIOS").suspend(); 
    754   } 
    755    
    756    
    757    
     780    CTimer::get("XIOS").suspend(); 
     781  } 
     782 
     783  bool cxios_is_defined_domain_zoom_ibegin_loc(domain_Ptr domain_hdl) 
     784  { 
     785     CTimer::get("XIOS").resume(); 
     786     bool isDefined = domain_hdl->zoom_ibegin_loc.hasInheritedValue(); 
     787     CTimer::get("XIOS").suspend(); 
     788     return isDefined; 
     789  } 
     790 
     791 
    758792  void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin) 
    759793  { 
    760      CTimer::get("XIOS").resume(); 
     794    CTimer::get("XIOS").resume(); 
    761795    domain_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    762      CTimer::get("XIOS").suspend(); 
    763   } 
    764    
     796    CTimer::get("XIOS").suspend(); 
     797  } 
     798 
    765799  void cxios_get_domain_zoom_jbegin(domain_Ptr domain_hdl, int* zoom_jbegin) 
    766800  { 
     801    CTimer::get("XIOS").resume(); 
    767802    *zoom_jbegin = domain_hdl->zoom_jbegin.getInheritedValue(); 
    768   } 
    769    
    770   bool cxios_is_defined_domain_zoom_jbegin(domain_Ptr domain_hdl ) 
    771   { 
    772      CTimer::get("XIOS").resume(); 
    773     return domain_hdl->zoom_jbegin.hasInheritedValue(); 
    774      CTimer::get("XIOS").suspend(); 
    775   } 
    776    
    777    
    778    
     803    CTimer::get("XIOS").suspend(); 
     804  } 
     805 
     806  bool cxios_is_defined_domain_zoom_jbegin(domain_Ptr domain_hdl) 
     807  { 
     808     CTimer::get("XIOS").resume(); 
     809     bool isDefined = domain_hdl->zoom_jbegin.hasInheritedValue(); 
     810     CTimer::get("XIOS").suspend(); 
     811     return isDefined; 
     812  } 
     813 
     814 
    779815  void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc) 
    780816  { 
    781      CTimer::get("XIOS").resume(); 
     817    CTimer::get("XIOS").resume(); 
    782818    domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    783      CTimer::get("XIOS").suspend(); 
    784   } 
    785    
     819    CTimer::get("XIOS").suspend(); 
     820  } 
     821 
    786822  void cxios_get_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int* zoom_jbegin_loc) 
    787823  { 
     824    CTimer::get("XIOS").resume(); 
    788825    *zoom_jbegin_loc = domain_hdl->zoom_jbegin_loc.getInheritedValue(); 
    789   } 
    790    
    791   bool cxios_is_defined_domain_zoom_jbegin_loc(domain_Ptr domain_hdl ) 
    792   { 
    793      CTimer::get("XIOS").resume(); 
    794     return domain_hdl->zoom_jbegin_loc.hasInheritedValue(); 
    795      CTimer::get("XIOS").suspend(); 
    796   } 
    797    
    798    
    799    
     826    CTimer::get("XIOS").suspend(); 
     827  } 
     828 
     829  bool cxios_is_defined_domain_zoom_jbegin_loc(domain_Ptr domain_hdl) 
     830  { 
     831     CTimer::get("XIOS").resume(); 
     832     bool isDefined = domain_hdl->zoom_jbegin_loc.hasInheritedValue(); 
     833     CTimer::get("XIOS").suspend(); 
     834     return isDefined; 
     835  } 
     836 
     837 
    800838  void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni) 
    801839  { 
    802      CTimer::get("XIOS").resume(); 
     840    CTimer::get("XIOS").resume(); 
    803841    domain_hdl->zoom_ni.setValue(zoom_ni); 
    804      CTimer::get("XIOS").suspend(); 
    805   } 
    806    
     842    CTimer::get("XIOS").suspend(); 
     843  } 
     844 
    807845  void cxios_get_domain_zoom_ni(domain_Ptr domain_hdl, int* zoom_ni) 
    808846  { 
     847    CTimer::get("XIOS").resume(); 
    809848    *zoom_ni = domain_hdl->zoom_ni.getInheritedValue(); 
    810   } 
    811    
    812   bool cxios_is_defined_domain_zoom_ni(domain_Ptr domain_hdl ) 
    813   { 
    814      CTimer::get("XIOS").resume(); 
    815     return domain_hdl->zoom_ni.hasInheritedValue(); 
    816      CTimer::get("XIOS").suspend(); 
    817   } 
    818    
    819    
    820    
     849    CTimer::get("XIOS").suspend(); 
     850  } 
     851 
     852  bool cxios_is_defined_domain_zoom_ni(domain_Ptr domain_hdl) 
     853  { 
     854     CTimer::get("XIOS").resume(); 
     855     bool isDefined = domain_hdl->zoom_ni.hasInheritedValue(); 
     856     CTimer::get("XIOS").suspend(); 
     857     return isDefined; 
     858  } 
     859 
     860 
    821861  void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc) 
    822862  { 
    823      CTimer::get("XIOS").resume(); 
     863    CTimer::get("XIOS").resume(); 
    824864    domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    825      CTimer::get("XIOS").suspend(); 
    826   } 
    827    
     865    CTimer::get("XIOS").suspend(); 
     866  } 
     867 
    828868  void cxios_get_domain_zoom_ni_loc(domain_Ptr domain_hdl, int* zoom_ni_loc) 
    829869  { 
     870    CTimer::get("XIOS").resume(); 
    830871    *zoom_ni_loc = domain_hdl->zoom_ni_loc.getInheritedValue(); 
    831   } 
    832    
    833   bool cxios_is_defined_domain_zoom_ni_loc(domain_Ptr domain_hdl ) 
    834   { 
    835      CTimer::get("XIOS").resume(); 
    836     return domain_hdl->zoom_ni_loc.hasInheritedValue(); 
    837      CTimer::get("XIOS").suspend(); 
    838   } 
    839    
    840    
    841    
     872    CTimer::get("XIOS").suspend(); 
     873  } 
     874 
     875  bool cxios_is_defined_domain_zoom_ni_loc(domain_Ptr domain_hdl) 
     876  { 
     877     CTimer::get("XIOS").resume(); 
     878     bool isDefined = domain_hdl->zoom_ni_loc.hasInheritedValue(); 
     879     CTimer::get("XIOS").suspend(); 
     880     return isDefined; 
     881  } 
     882 
     883 
    842884  void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj) 
    843885  { 
    844      CTimer::get("XIOS").resume(); 
     886    CTimer::get("XIOS").resume(); 
    845887    domain_hdl->zoom_nj.setValue(zoom_nj); 
    846      CTimer::get("XIOS").suspend(); 
    847   } 
    848    
     888    CTimer::get("XIOS").suspend(); 
     889  } 
     890 
    849891  void cxios_get_domain_zoom_nj(domain_Ptr domain_hdl, int* zoom_nj) 
    850892  { 
     893    CTimer::get("XIOS").resume(); 
    851894    *zoom_nj = domain_hdl->zoom_nj.getInheritedValue(); 
    852   } 
    853    
    854   bool cxios_is_defined_domain_zoom_nj(domain_Ptr domain_hdl ) 
    855   { 
    856      CTimer::get("XIOS").resume(); 
    857     return domain_hdl->zoom_nj.hasInheritedValue(); 
    858      CTimer::get("XIOS").suspend(); 
    859   } 
    860    
    861    
    862    
     895    CTimer::get("XIOS").suspend(); 
     896  } 
     897 
     898  bool cxios_is_defined_domain_zoom_nj(domain_Ptr domain_hdl) 
     899  { 
     900     CTimer::get("XIOS").resume(); 
     901     bool isDefined = domain_hdl->zoom_nj.hasInheritedValue(); 
     902     CTimer::get("XIOS").suspend(); 
     903     return isDefined; 
     904  } 
     905 
     906 
    863907  void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc) 
    864908  { 
    865      CTimer::get("XIOS").resume(); 
     909    CTimer::get("XIOS").resume(); 
    866910    domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    867      CTimer::get("XIOS").suspend(); 
    868   } 
    869    
     911    CTimer::get("XIOS").suspend(); 
     912  } 
     913 
    870914  void cxios_get_domain_zoom_nj_loc(domain_Ptr domain_hdl, int* zoom_nj_loc) 
    871915  { 
     916    CTimer::get("XIOS").resume(); 
    872917    *zoom_nj_loc = domain_hdl->zoom_nj_loc.getInheritedValue(); 
    873   } 
    874    
    875   bool cxios_is_defined_domain_zoom_nj_loc(domain_Ptr domain_hdl ) 
    876   { 
    877      CTimer::get("XIOS").resume(); 
    878     return domain_hdl->zoom_nj_loc.hasInheritedValue(); 
    879      CTimer::get("XIOS").suspend(); 
    880   } 
    881    
    882    
    883    
    884    
     918    CTimer::get("XIOS").suspend(); 
     919  } 
     920 
     921  bool cxios_is_defined_domain_zoom_nj_loc(domain_Ptr domain_hdl) 
     922  { 
     923     CTimer::get("XIOS").resume(); 
     924     bool isDefined = domain_hdl->zoom_nj_loc.hasInheritedValue(); 
     925     CTimer::get("XIOS").suspend(); 
     926     return isDefined; 
     927  } 
    885928} 

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

    r546 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CDomainGroup*  domaingroup_Ptr; 
    19    
     18  typedef xios::CDomainGroup* domaingroup_Ptr; 
     19 
    2020  void cxios_set_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2) 
    2121  { 
    2222    CTimer::get("XIOS").resume(); 
    23     CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ; 
     23    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    2424    domaingroup_hdl->bounds_lat.reference(tmp.copy()); 
    2525     CTimer::get("XIOS").suspend(); 
    2626  } 
    27    
     27 
    2828  void cxios_get_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2) 
    2929  { 
    3030    CTimer::get("XIOS").resume(); 
    31     CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ; 
    32     tmp=domaingroup_hdl->bounds_lat.getInheritedValue() ; 
    33      CTimer::get("XIOS").suspend(); 
    34   } 
    35    
    36   bool cxios_is_defined_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl ) 
    37   { 
    38      CTimer::get("XIOS").resume(); 
    39     return domaingroup_hdl->bounds_lat.hasInheritedValue(); 
    40      CTimer::get("XIOS").suspend(); 
    41   } 
    42    
    43    
    44    
     31    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
     32    tmp=domaingroup_hdl->bounds_lat.getInheritedValue(); 
     33     CTimer::get("XIOS").suspend(); 
     34  } 
     35 
     36  bool cxios_is_defined_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl) 
     37  { 
     38     CTimer::get("XIOS").resume(); 
     39     bool isDefined = domaingroup_hdl->bounds_lat.hasInheritedValue(); 
     40     CTimer::get("XIOS").suspend(); 
     41     return isDefined; 
     42  } 
     43 
     44 
    4545  void cxios_set_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2) 
    4646  { 
    4747    CTimer::get("XIOS").resume(); 
    48     CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ; 
     48    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    4949    domaingroup_hdl->bounds_lon.reference(tmp.copy()); 
    5050     CTimer::get("XIOS").suspend(); 
    5151  } 
    52    
     52 
    5353  void cxios_get_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2) 
    5454  { 
    5555    CTimer::get("XIOS").resume(); 
    56     CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ; 
    57     tmp=domaingroup_hdl->bounds_lon.getInheritedValue() ; 
    58      CTimer::get("XIOS").suspend(); 
    59   } 
    60    
    61   bool cxios_is_defined_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl ) 
    62   { 
    63      CTimer::get("XIOS").resume(); 
    64     return domaingroup_hdl->bounds_lon.hasInheritedValue(); 
    65      CTimer::get("XIOS").suspend(); 
    66   } 
    67    
    68    
    69    
     56    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
     57    tmp=domaingroup_hdl->bounds_lon.getInheritedValue(); 
     58     CTimer::get("XIOS").suspend(); 
     59  } 
     60 
     61  bool cxios_is_defined_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl) 
     62  { 
     63     CTimer::get("XIOS").resume(); 
     64     bool isDefined = domaingroup_hdl->bounds_lon.hasInheritedValue(); 
     65     CTimer::get("XIOS").suspend(); 
     66     return isDefined; 
     67  } 
     68 
     69 
    7070  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim) 
    7171  { 
    72      CTimer::get("XIOS").resume(); 
     72    CTimer::get("XIOS").resume(); 
    7373    domaingroup_hdl->data_dim.setValue(data_dim); 
    74      CTimer::get("XIOS").suspend(); 
    75   } 
    76    
     74    CTimer::get("XIOS").suspend(); 
     75  } 
     76 
    7777  void cxios_get_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int* data_dim) 
    7878  { 
     79    CTimer::get("XIOS").resume(); 
    7980    *data_dim = domaingroup_hdl->data_dim.getInheritedValue(); 
    80   } 
    81    
    82   bool cxios_is_defined_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl ) 
    83   { 
    84      CTimer::get("XIOS").resume(); 
    85     return domaingroup_hdl->data_dim.hasInheritedValue(); 
    86      CTimer::get("XIOS").suspend(); 
    87   } 
    88    
    89    
    90    
     81    CTimer::get("XIOS").suspend(); 
     82  } 
     83 
     84  bool cxios_is_defined_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl) 
     85  { 
     86     CTimer::get("XIOS").resume(); 
     87     bool isDefined = domaingroup_hdl->data_dim.hasInheritedValue(); 
     88     CTimer::get("XIOS").suspend(); 
     89     return isDefined; 
     90  } 
     91 
     92 
    9193  void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1) 
    9294  { 
    9395    CTimer::get("XIOS").resume(); 
    94     CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     96    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData); 
    9597    domaingroup_hdl->data_i_index.reference(tmp.copy()); 
    9698     CTimer::get("XIOS").suspend(); 
    9799  } 
    98    
     100 
    99101  void cxios_get_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1) 
    100102  { 
    101103    CTimer::get("XIOS").resume(); 
    102     CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
    103     tmp=domaingroup_hdl->data_i_index.getInheritedValue() ; 
    104      CTimer::get("XIOS").suspend(); 
    105   } 
    106    
    107   bool cxios_is_defined_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl ) 
    108   { 
    109      CTimer::get("XIOS").resume(); 
    110     return domaingroup_hdl->data_i_index.hasInheritedValue(); 
    111      CTimer::get("XIOS").suspend(); 
    112   } 
    113    
    114    
    115    
     104    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData); 
     105    tmp=domaingroup_hdl->data_i_index.getInheritedValue(); 
     106     CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = domaingroup_hdl->data_i_index.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    116118  void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin) 
    117119  { 
    118      CTimer::get("XIOS").resume(); 
     120    CTimer::get("XIOS").resume(); 
    119121    domaingroup_hdl->data_ibegin.setValue(data_ibegin); 
    120      CTimer::get("XIOS").suspend(); 
    121   } 
    122    
     122    CTimer::get("XIOS").suspend(); 
     123  } 
     124 
    123125  void cxios_get_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* data_ibegin) 
    124126  { 
     127    CTimer::get("XIOS").resume(); 
    125128    *data_ibegin = domaingroup_hdl->data_ibegin.getInheritedValue(); 
    126   } 
    127    
    128   bool cxios_is_defined_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl ) 
    129   { 
    130      CTimer::get("XIOS").resume(); 
    131     return domaingroup_hdl->data_ibegin.hasInheritedValue(); 
    132      CTimer::get("XIOS").suspend(); 
    133   } 
    134    
    135    
    136    
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = domaingroup_hdl->data_ibegin.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    137141  void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1) 
    138142  { 
    139143    CTimer::get("XIOS").resume(); 
    140     CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     144    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData); 
    141145    domaingroup_hdl->data_j_index.reference(tmp.copy()); 
    142146     CTimer::get("XIOS").suspend(); 
    143147  } 
    144    
     148 
    145149  void cxios_get_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1) 
    146150  { 
    147151    CTimer::get("XIOS").resume(); 
    148     CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
    149     tmp=domaingroup_hdl->data_j_index.getInheritedValue() ; 
    150      CTimer::get("XIOS").suspend(); 
    151   } 
    152    
    153   bool cxios_is_defined_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl ) 
    154   { 
    155      CTimer::get("XIOS").resume(); 
    156     return domaingroup_hdl->data_j_index.hasInheritedValue(); 
    157      CTimer::get("XIOS").suspend(); 
    158   } 
    159    
    160    
    161    
     152    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData); 
     153    tmp=domaingroup_hdl->data_j_index.getInheritedValue(); 
     154     CTimer::get("XIOS").suspend(); 
     155  } 
     156 
     157  bool cxios_is_defined_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl) 
     158  { 
     159     CTimer::get("XIOS").resume(); 
     160     bool isDefined = domaingroup_hdl->data_j_index.hasInheritedValue(); 
     161     CTimer::get("XIOS").suspend(); 
     162     return isDefined; 
     163  } 
     164 
     165 
    162166  void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin) 
    163167  { 
    164      CTimer::get("XIOS").resume(); 
     168    CTimer::get("XIOS").resume(); 
    165169    domaingroup_hdl->data_jbegin.setValue(data_jbegin); 
    166      CTimer::get("XIOS").suspend(); 
    167   } 
    168    
     170    CTimer::get("XIOS").suspend(); 
     171  } 
     172 
    169173  void cxios_get_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* data_jbegin) 
    170174  { 
     175    CTimer::get("XIOS").resume(); 
    171176    *data_jbegin = domaingroup_hdl->data_jbegin.getInheritedValue(); 
    172   } 
    173    
    174   bool cxios_is_defined_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl ) 
    175   { 
    176      CTimer::get("XIOS").resume(); 
    177     return domaingroup_hdl->data_jbegin.hasInheritedValue(); 
    178      CTimer::get("XIOS").suspend(); 
    179   } 
    180    
    181    
    182    
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  bool cxios_is_defined_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl) 
     181  { 
     182     CTimer::get("XIOS").resume(); 
     183     bool isDefined = domaingroup_hdl->data_jbegin.hasInheritedValue(); 
     184     CTimer::get("XIOS").suspend(); 
     185     return isDefined; 
     186  } 
     187 
     188 
    183189  void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index) 
    184190  { 
    185      CTimer::get("XIOS").resume(); 
     191    CTimer::get("XIOS").resume(); 
    186192    domaingroup_hdl->data_n_index.setValue(data_n_index); 
    187      CTimer::get("XIOS").suspend(); 
    188   } 
    189    
     193    CTimer::get("XIOS").suspend(); 
     194  } 
     195 
    190196  void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index) 
    191197  { 
     198    CTimer::get("XIOS").resume(); 
    192199    *data_n_index = domaingroup_hdl->data_n_index.getInheritedValue(); 
    193   } 
    194    
    195   bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl ) 
    196   { 
    197      CTimer::get("XIOS").resume(); 
    198     return domaingroup_hdl->data_n_index.hasInheritedValue(); 
    199      CTimer::get("XIOS").suspend(); 
    200   } 
    201    
    202    
    203    
     200    CTimer::get("XIOS").suspend(); 
     201  } 
     202 
     203  bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl) 
     204  { 
     205     CTimer::get("XIOS").resume(); 
     206     bool isDefined = domaingroup_hdl->data_n_index.hasInheritedValue(); 
     207     CTimer::get("XIOS").suspend(); 
     208     return isDefined; 
     209  } 
     210 
     211 
    204212  void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni) 
    205213  { 
    206      CTimer::get("XIOS").resume(); 
     214    CTimer::get("XIOS").resume(); 
    207215    domaingroup_hdl->data_ni.setValue(data_ni); 
    208      CTimer::get("XIOS").suspend(); 
    209   } 
    210    
     216    CTimer::get("XIOS").suspend(); 
     217  } 
     218 
    211219  void cxios_get_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int* data_ni) 
    212220  { 
     221    CTimer::get("XIOS").resume(); 
    213222    *data_ni = domaingroup_hdl->data_ni.getInheritedValue(); 
    214   } 
    215    
    216   bool cxios_is_defined_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl ) 
    217   { 
    218      CTimer::get("XIOS").resume(); 
    219     return domaingroup_hdl->data_ni.hasInheritedValue(); 
    220      CTimer::get("XIOS").suspend(); 
    221   } 
    222    
    223    
    224    
     223    CTimer::get("XIOS").suspend(); 
     224  } 
     225 
     226  bool cxios_is_defined_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl) 
     227  { 
     228     CTimer::get("XIOS").resume(); 
     229     bool isDefined = domaingroup_hdl->data_ni.hasInheritedValue(); 
     230     CTimer::get("XIOS").suspend(); 
     231     return isDefined; 
     232  } 
     233 
     234 
    225235  void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj) 
    226236  { 
    227      CTimer::get("XIOS").resume(); 
     237    CTimer::get("XIOS").resume(); 
    228238    domaingroup_hdl->data_nj.setValue(data_nj); 
    229      CTimer::get("XIOS").suspend(); 
    230   } 
    231    
     239    CTimer::get("XIOS").suspend(); 
     240  } 
     241 
    232242  void cxios_get_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int* data_nj) 
    233243  { 
     244    CTimer::get("XIOS").resume(); 
    234245    *data_nj = domaingroup_hdl->data_nj.getInheritedValue(); 
    235   } 
    236    
    237   bool cxios_is_defined_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl ) 
    238   { 
    239      CTimer::get("XIOS").resume(); 
    240     return domaingroup_hdl->data_nj.hasInheritedValue(); 
    241      CTimer::get("XIOS").suspend(); 
    242   } 
    243    
    244    
    245    
     246    CTimer::get("XIOS").suspend(); 
     247  } 
     248 
     249  bool cxios_is_defined_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl) 
     250  { 
     251     CTimer::get("XIOS").resume(); 
     252     bool isDefined = domaingroup_hdl->data_nj.hasInheritedValue(); 
     253     CTimer::get("XIOS").suspend(); 
     254     return isDefined; 
     255  } 
     256 
     257 
    246258  void cxios_set_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    247259  { 
    248260    std::string domain_group_ref_str; 
    249     if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
    250      CTimer::get("XIOS").resume(); 
     261    if (!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
     262    CTimer::get("XIOS").resume(); 
    251263    domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    252      CTimer::get("XIOS").suspend(); 
    253   } 
    254    
     264    CTimer::get("XIOS").suspend(); 
     265  } 
     266 
    255267  void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size) 
    256268  { 
    257      CTimer::get("XIOS").resume(); 
    258     if(!string_copy(domaingroup_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size)) 
    259       ERROR("void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
    260      CTimer::get("XIOS").suspend(); 
    261   } 
    262    
    263   bool cxios_is_defined_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl ) 
    264   { 
    265      CTimer::get("XIOS").resume(); 
    266     return domaingroup_hdl->domain_group_ref.hasInheritedValue(); 
    267      CTimer::get("XIOS").suspend(); 
    268   } 
    269    
    270    
    271    
     269    CTimer::get("XIOS").resume(); 
     270    if (!string_copy(domaingroup_hdl->domain_group_ref.getInheritedValue(), domain_group_ref, domain_group_ref_size)) 
     271      ERROR("void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)", << "Input string is too short"); 
     272    CTimer::get("XIOS").suspend(); 
     273  } 
     274 
     275  bool cxios_is_defined_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl) 
     276  { 
     277     CTimer::get("XIOS").resume(); 
     278     bool isDefined = domaingroup_hdl->domain_group_ref.hasInheritedValue(); 
     279     CTimer::get("XIOS").suspend(); 
     280     return isDefined; 
     281  } 
     282 
     283 
    272284  void cxios_set_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_ref, int domain_ref_size) 
    273285  { 
    274286    std::string domain_ref_str; 
    275     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    276      CTimer::get("XIOS").resume(); 
     287    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     288    CTimer::get("XIOS").resume(); 
    277289    domaingroup_hdl->domain_ref.setValue(domain_ref_str); 
    278      CTimer::get("XIOS").suspend(); 
    279   } 
    280    
     290    CTimer::get("XIOS").suspend(); 
     291  } 
     292 
    281293  void cxios_get_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, char * domain_ref, int domain_ref_size) 
    282294  { 
    283      CTimer::get("XIOS").resume(); 
    284     if(!string_copy(domaingroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    285       ERROR("void cxios_get_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    286      CTimer::get("XIOS").suspend(); 
    287   } 
    288    
    289   bool cxios_is_defined_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl ) 
    290   { 
    291      CTimer::get("XIOS").resume(); 
    292     return domaingroup_hdl->domain_ref.hasInheritedValue(); 
    293      CTimer::get("XIOS").suspend(); 
    294   } 
    295    
    296    
    297    
     295    CTimer::get("XIOS").resume(); 
     296    if (!string_copy(domaingroup_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size)) 
     297      ERROR("void cxios_get_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short"); 
     298    CTimer::get("XIOS").suspend(); 
     299  } 
     300 
     301  bool cxios_is_defined_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl) 
     302  { 
     303     CTimer::get("XIOS").resume(); 
     304     bool isDefined = domaingroup_hdl->domain_ref.hasInheritedValue(); 
     305     CTimer::get("XIOS").suspend(); 
     306     return isDefined; 
     307  } 
     308 
     309 
    298310  void cxios_set_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, const char * group_ref, int group_ref_size) 
    299311  { 
    300312    std::string group_ref_str; 
    301     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    302      CTimer::get("XIOS").resume(); 
     313    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     314    CTimer::get("XIOS").resume(); 
    303315    domaingroup_hdl->group_ref.setValue(group_ref_str); 
    304      CTimer::get("XIOS").suspend(); 
    305   } 
    306    
     316    CTimer::get("XIOS").suspend(); 
     317  } 
     318 
    307319  void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size) 
    308320  { 
    309      CTimer::get("XIOS").resume(); 
    310     if(!string_copy(domaingroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    311       ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    312      CTimer::get("XIOS").suspend(); 
    313   } 
    314    
    315   bool cxios_is_defined_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl ) 
    316   { 
    317      CTimer::get("XIOS").resume(); 
    318     return domaingroup_hdl->group_ref.hasInheritedValue(); 
    319      CTimer::get("XIOS").suspend(); 
    320   } 
    321    
    322    
    323    
     321    CTimer::get("XIOS").resume(); 
     322    if (!string_copy(domaingroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     323      ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     324    CTimer::get("XIOS").suspend(); 
     325  } 
     326 
     327  bool cxios_is_defined_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl) 
     328  { 
     329     CTimer::get("XIOS").resume(); 
     330     bool isDefined = domaingroup_hdl->group_ref.hasInheritedValue(); 
     331     CTimer::get("XIOS").suspend(); 
     332     return isDefined; 
     333  } 
     334 
     335 
    324336  void cxios_set_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl, int* i_index, int extent1, int extent2) 
    325337  { 
    326338    CTimer::get("XIOS").resume(); 
    327     CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ; 
     339    CArray<int,2> tmp(i_index, shape(extent1, extent2), neverDeleteData); 
    328340    domaingroup_hdl->i_index.reference(tmp.copy()); 
    329341     CTimer::get("XIOS").suspend(); 
    330342  } 
    331    
     343 
    332344  void cxios_get_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl, int* i_index, int extent1, int extent2) 
    333345  { 
    334346    CTimer::get("XIOS").resume(); 
    335     CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ; 
    336     tmp=domaingroup_hdl->i_index.getInheritedValue() ; 
    337      CTimer::get("XIOS").suspend(); 
    338   } 
    339    
    340   bool cxios_is_defined_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl ) 
    341   { 
    342      CTimer::get("XIOS").resume(); 
    343     return domaingroup_hdl->i_index.hasInheritedValue(); 
    344      CTimer::get("XIOS").suspend(); 
    345   } 
    346    
    347    
    348    
     347    CArray<int,2> tmp(i_index, shape(extent1, extent2), neverDeleteData); 
     348    tmp=domaingroup_hdl->i_index.getInheritedValue(); 
     349     CTimer::get("XIOS").suspend(); 
     350  } 
     351 
     352  bool cxios_is_defined_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl) 
     353  { 
     354     CTimer::get("XIOS").resume(); 
     355     bool isDefined = domaingroup_hdl->i_index.hasInheritedValue(); 
     356     CTimer::get("XIOS").suspend(); 
     357     return isDefined; 
     358  } 
     359 
     360 
    349361  void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin) 
    350362  { 
    351      CTimer::get("XIOS").resume(); 
     363    CTimer::get("XIOS").resume(); 
    352364    domaingroup_hdl->ibegin.setValue(ibegin); 
    353      CTimer::get("XIOS").suspend(); 
    354   } 
    355    
     365    CTimer::get("XIOS").suspend(); 
     366  } 
     367 
    356368  void cxios_get_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int* ibegin) 
    357369  { 
     370    CTimer::get("XIOS").resume(); 
    358371    *ibegin = domaingroup_hdl->ibegin.getInheritedValue(); 
    359   } 
    360    
    361   bool cxios_is_defined_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl ) 
    362   { 
    363      CTimer::get("XIOS").resume(); 
    364     return domaingroup_hdl->ibegin.hasInheritedValue(); 
    365      CTimer::get("XIOS").suspend(); 
    366   } 
    367    
    368    
    369    
     372    CTimer::get("XIOS").suspend(); 
     373  } 
     374 
     375  bool cxios_is_defined_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl) 
     376  { 
     377     CTimer::get("XIOS").resume(); 
     378     bool isDefined = domaingroup_hdl->ibegin.hasInheritedValue(); 
     379     CTimer::get("XIOS").suspend(); 
     380     return isDefined; 
     381  } 
     382 
     383 
    370384  void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend) 
    371385  { 
    372      CTimer::get("XIOS").resume(); 
     386    CTimer::get("XIOS").resume(); 
    373387    domaingroup_hdl->iend.setValue(iend); 
    374      CTimer::get("XIOS").suspend(); 
    375   } 
    376    
     388    CTimer::get("XIOS").suspend(); 
     389  } 
     390 
    377391  void cxios_get_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int* iend) 
    378392  { 
     393    CTimer::get("XIOS").resume(); 
    379394    *iend = domaingroup_hdl->iend.getInheritedValue(); 
    380   } 
    381    
    382   bool cxios_is_defined_domaingroup_iend(domaingroup_Ptr domaingroup_hdl ) 
    383   { 
    384      CTimer::get("XIOS").resume(); 
    385     return domaingroup_hdl->iend.hasInheritedValue(); 
    386      CTimer::get("XIOS").suspend(); 
    387   } 
    388    
    389    
    390    
     395    CTimer::get("XIOS").suspend(); 
     396  } 
     397 
     398  bool cxios_is_defined_domaingroup_iend(domaingroup_Ptr domaingroup_hdl) 
     399  { 
     400     CTimer::get("XIOS").resume(); 
     401     bool isDefined = domaingroup_hdl->iend.hasInheritedValue(); 
     402     CTimer::get("XIOS").suspend(); 
     403     return isDefined; 
     404  } 
     405 
     406 
    391407  void cxios_set_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl, int* j_index, int extent1, int extent2) 
    392408  { 
    393409    CTimer::get("XIOS").resume(); 
    394     CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ; 
     410    CArray<int,2> tmp(j_index, shape(extent1, extent2), neverDeleteData); 
    395411    domaingroup_hdl->j_index.reference(tmp.copy()); 
    396412     CTimer::get("XIOS").suspend(); 
    397413  } 
    398    
     414 
    399415  void cxios_get_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl, int* j_index, int extent1, int extent2) 
    400416  { 
    401417    CTimer::get("XIOS").resume(); 
    402     CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ; 
    403     tmp=domaingroup_hdl->j_index.getInheritedValue() ; 
    404      CTimer::get("XIOS").suspend(); 
    405   } 
    406    
    407   bool cxios_is_defined_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl ) 
    408   { 
    409      CTimer::get("XIOS").resume(); 
    410     return domaingroup_hdl->j_index.hasInheritedValue(); 
    411      CTimer::get("XIOS").suspend(); 
    412   } 
    413    
    414    
    415    
     418    CArray<int,2> tmp(j_index, shape(extent1, extent2), neverDeleteData); 
     419    tmp=domaingroup_hdl->j_index.getInheritedValue(); 
     420     CTimer::get("XIOS").suspend(); 
     421  } 
     422 
     423  bool cxios_is_defined_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl) 
     424  { 
     425     CTimer::get("XIOS").resume(); 
     426     bool isDefined = domaingroup_hdl->j_index.hasInheritedValue(); 
     427     CTimer::get("XIOS").suspend(); 
     428     return isDefined; 
     429  } 
     430 
     431 
    416432  void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin) 
    417433  { 
    418      CTimer::get("XIOS").resume(); 
     434    CTimer::get("XIOS").resume(); 
    419435    domaingroup_hdl->jbegin.setValue(jbegin); 
    420      CTimer::get("XIOS").suspend(); 
    421   } 
    422    
     436    CTimer::get("XIOS").suspend(); 
     437  } 
     438 
    423439  void cxios_get_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int* jbegin) 
    424440  { 
     441    CTimer::get("XIOS").resume(); 
    425442    *jbegin = domaingroup_hdl->jbegin.getInheritedValue(); 
    426   } 
    427    
    428   bool cxios_is_defined_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl ) 
    429   { 
    430      CTimer::get("XIOS").resume(); 
    431     return domaingroup_hdl->jbegin.hasInheritedValue(); 
    432      CTimer::get("XIOS").suspend(); 
    433   } 
    434    
    435    
    436    
     443    CTimer::get("XIOS").suspend(); 
     444  } 
     445 
     446  bool cxios_is_defined_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl) 
     447  { 
     448     CTimer::get("XIOS").resume(); 
     449     bool isDefined = domaingroup_hdl->jbegin.hasInheritedValue(); 
     450     CTimer::get("XIOS").suspend(); 
     451     return isDefined; 
     452  } 
     453 
     454 
    437455  void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend) 
    438456  { 
    439      CTimer::get("XIOS").resume(); 
     457    CTimer::get("XIOS").resume(); 
    440458    domaingroup_hdl->jend.setValue(jend); 
    441      CTimer::get("XIOS").suspend(); 
    442   } 
    443    
     459    CTimer::get("XIOS").suspend(); 
     460  } 
     461 
    444462  void cxios_get_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int* jend) 
    445463  { 
     464    CTimer::get("XIOS").resume(); 
    446465    *jend = domaingroup_hdl->jend.getInheritedValue(); 
    447   } 
    448    
    449   bool cxios_is_defined_domaingroup_jend(domaingroup_Ptr domaingroup_hdl ) 
    450   { 
    451      CTimer::get("XIOS").resume(); 
    452     return domaingroup_hdl->jend.hasInheritedValue(); 
    453      CTimer::get("XIOS").suspend(); 
    454   } 
    455    
    456    
    457    
     466    CTimer::get("XIOS").suspend(); 
     467  } 
     468 
     469  bool cxios_is_defined_domaingroup_jend(domaingroup_Ptr domaingroup_hdl) 
     470  { 
     471     CTimer::get("XIOS").resume(); 
     472     bool isDefined = domaingroup_hdl->jend.hasInheritedValue(); 
     473     CTimer::get("XIOS").suspend(); 
     474     return isDefined; 
     475  } 
     476 
     477 
    458478  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    459479  { 
    460480    CTimer::get("XIOS").resume(); 
    461     CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     481    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    462482    domaingroup_hdl->latvalue.reference(tmp.copy()); 
    463483     CTimer::get("XIOS").suspend(); 
    464484  } 
    465    
     485 
    466486  void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    467487  { 
    468488    CTimer::get("XIOS").resume(); 
    469     CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
    470     tmp=domaingroup_hdl->latvalue.getInheritedValue() ; 
    471      CTimer::get("XIOS").suspend(); 
    472   } 
    473    
    474   bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl ) 
    475   { 
    476      CTimer::get("XIOS").resume(); 
    477     return domaingroup_hdl->latvalue.hasInheritedValue(); 
    478      CTimer::get("XIOS").suspend(); 
    479   } 
    480    
    481    
    482    
     489    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
     490    tmp=domaingroup_hdl->latvalue.getInheritedValue(); 
     491     CTimer::get("XIOS").suspend(); 
     492  } 
     493 
     494  bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl) 
     495  { 
     496     CTimer::get("XIOS").resume(); 
     497     bool isDefined = domaingroup_hdl->latvalue.hasInheritedValue(); 
     498     CTimer::get("XIOS").suspend(); 
     499     return isDefined; 
     500  } 
     501 
     502 
    483503  void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size) 
    484504  { 
    485505    std::string long_name_str; 
    486     if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
    487      CTimer::get("XIOS").resume(); 
     506    if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
     507    CTimer::get("XIOS").resume(); 
    488508    domaingroup_hdl->long_name.setValue(long_name_str); 
    489      CTimer::get("XIOS").suspend(); 
    490   } 
    491    
     509    CTimer::get("XIOS").suspend(); 
     510  } 
     511 
    492512  void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size) 
    493513  { 
    494      CTimer::get("XIOS").resume(); 
    495     if(!string_copy(domaingroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    496       ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    497      CTimer::get("XIOS").suspend(); 
    498   } 
    499    
    500   bool cxios_is_defined_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl ) 
    501   { 
    502      CTimer::get("XIOS").resume(); 
    503     return domaingroup_hdl->long_name.hasInheritedValue(); 
    504      CTimer::get("XIOS").suspend(); 
    505   } 
    506    
    507    
    508    
     514    CTimer::get("XIOS").resume(); 
     515    if (!string_copy(domaingroup_hdl->long_name.getInheritedValue(), long_name, long_name_size)) 
     516      ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", << "Input string is too short"); 
     517    CTimer::get("XIOS").suspend(); 
     518  } 
     519 
     520  bool cxios_is_defined_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl) 
     521  { 
     522     CTimer::get("XIOS").resume(); 
     523     bool isDefined = domaingroup_hdl->long_name.hasInheritedValue(); 
     524     CTimer::get("XIOS").suspend(); 
     525     return isDefined; 
     526  } 
     527 
     528 
    509529  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    510530  { 
    511531    CTimer::get("XIOS").resume(); 
    512     CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     532    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    513533    domaingroup_hdl->lonvalue.reference(tmp.copy()); 
    514534     CTimer::get("XIOS").suspend(); 
    515535  } 
    516    
     536 
    517537  void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    518538  { 
    519539    CTimer::get("XIOS").resume(); 
    520     CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
    521     tmp=domaingroup_hdl->lonvalue.getInheritedValue() ; 
    522      CTimer::get("XIOS").suspend(); 
    523   } 
    524    
    525   bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl ) 
    526   { 
    527      CTimer::get("XIOS").resume(); 
    528     return domaingroup_hdl->lonvalue.hasInheritedValue(); 
    529      CTimer::get("XIOS").suspend(); 
    530   } 
    531    
    532    
    533    
     540    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
     541    tmp=domaingroup_hdl->lonvalue.getInheritedValue(); 
     542     CTimer::get("XIOS").suspend(); 
     543  } 
     544 
     545  bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl) 
     546  { 
     547     CTimer::get("XIOS").resume(); 
     548     bool isDefined = domaingroup_hdl->lonvalue.hasInheritedValue(); 
     549     CTimer::get("XIOS").suspend(); 
     550     return isDefined; 
     551  } 
     552 
     553 
    534554  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    535555  { 
    536556    CTimer::get("XIOS").resume(); 
    537     CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     557    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    538558    domaingroup_hdl->mask.reference(tmp.copy()); 
    539559     CTimer::get("XIOS").suspend(); 
    540560  } 
    541    
     561 
    542562  void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    543563  { 
    544564    CTimer::get("XIOS").resume(); 
    545     CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
    546     tmp=domaingroup_hdl->mask.getInheritedValue() ; 
    547      CTimer::get("XIOS").suspend(); 
    548   } 
    549    
    550   bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl ) 
    551   { 
    552      CTimer::get("XIOS").resume(); 
    553     return domaingroup_hdl->mask.hasInheritedValue(); 
    554      CTimer::get("XIOS").suspend(); 
    555   } 
    556    
    557    
    558    
     565    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
     566    tmp=domaingroup_hdl->mask.getInheritedValue(); 
     567     CTimer::get("XIOS").suspend(); 
     568  } 
     569 
     570  bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl) 
     571  { 
     572     CTimer::get("XIOS").resume(); 
     573     bool isDefined = domaingroup_hdl->mask.hasInheritedValue(); 
     574     CTimer::get("XIOS").suspend(); 
     575     return isDefined; 
     576  } 
     577 
     578 
    559579  void cxios_set_domaingroup_name(domaingroup_Ptr domaingroup_hdl, const char * name, int name_size) 
    560580  { 
    561581    std::string name_str; 
    562     if(!cstr2string(name, name_size, name_str)) return; 
    563      CTimer::get("XIOS").resume(); 
     582    if (!cstr2string(name, name_size, name_str)) return; 
     583    CTimer::get("XIOS").resume(); 
    564584    domaingroup_hdl->name.setValue(name_str); 
    565      CTimer::get("XIOS").suspend(); 
    566   } 
    567    
     585    CTimer::get("XIOS").suspend(); 
     586  } 
     587 
    568588  void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size) 
    569589  { 
    570      CTimer::get("XIOS").resume(); 
    571     if(!string_copy(domaingroup_hdl->name.getInheritedValue(),name , name_size)) 
    572       ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    573      CTimer::get("XIOS").suspend(); 
    574   } 
    575    
    576   bool cxios_is_defined_domaingroup_name(domaingroup_Ptr domaingroup_hdl ) 
    577   { 
    578      CTimer::get("XIOS").resume(); 
    579     return domaingroup_hdl->name.hasInheritedValue(); 
    580      CTimer::get("XIOS").suspend(); 
    581   } 
    582    
    583    
    584    
     590    CTimer::get("XIOS").resume(); 
     591    if (!string_copy(domaingroup_hdl->name.getInheritedValue(), name, name_size)) 
     592      ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     593    CTimer::get("XIOS").suspend(); 
     594  } 
     595 
     596  bool cxios_is_defined_domaingroup_name(domaingroup_Ptr domaingroup_hdl) 
     597  { 
     598     CTimer::get("XIOS").resume(); 
     599     bool isDefined = domaingroup_hdl->name.hasInheritedValue(); 
     600     CTimer::get("XIOS").suspend(); 
     601     return isDefined; 
     602  } 
     603 
     604 
    585605  void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni) 
    586606  { 
    587      CTimer::get("XIOS").resume(); 
     607    CTimer::get("XIOS").resume(); 
    588608    domaingroup_hdl->ni.setValue(ni); 
    589      CTimer::get("XIOS").suspend(); 
    590   } 
    591    
     609    CTimer::get("XIOS").suspend(); 
     610  } 
     611 
    592612  void cxios_get_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int* ni) 
    593613  { 
     614    CTimer::get("XIOS").resume(); 
    594615    *ni = domaingroup_hdl->ni.getInheritedValue(); 
    595   } 
    596    
    597   bool cxios_is_defined_domaingroup_ni(domaingroup_Ptr domaingroup_hdl ) 
    598   { 
    599      CTimer::get("XIOS").resume(); 
    600     return domaingroup_hdl->ni.hasInheritedValue(); 
    601      CTimer::get("XIOS").suspend(); 
    602   } 
    603    
    604    
    605    
     616    CTimer::get("XIOS").suspend(); 
     617  } 
     618 
     619  bool cxios_is_defined_domaingroup_ni(domaingroup_Ptr domaingroup_hdl) 
     620  { 
     621     CTimer::get("XIOS").resume(); 
     622     bool isDefined = domaingroup_hdl->ni.hasInheritedValue(); 
     623     CTimer::get("XIOS").suspend(); 
     624     return isDefined; 
     625  } 
     626 
     627 
    606628  void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo) 
    607629  { 
    608      CTimer::get("XIOS").resume(); 
     630    CTimer::get("XIOS").resume(); 
    609631    domaingroup_hdl->ni_glo.setValue(ni_glo); 
    610      CTimer::get("XIOS").suspend(); 
    611   } 
    612    
     632    CTimer::get("XIOS").suspend(); 
     633  } 
     634 
    613635  void cxios_get_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int* ni_glo) 
    614636  { 
     637    CTimer::get("XIOS").resume(); 
    615638    *ni_glo = domaingroup_hdl->ni_glo.getInheritedValue(); 
    616   } 
    617    
    618   bool cxios_is_defined_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl ) 
    619   { 
    620      CTimer::get("XIOS").resume(); 
    621     return domaingroup_hdl->ni_glo.hasInheritedValue(); 
    622      CTimer::get("XIOS").suspend(); 
    623   } 
    624    
    625    
    626    
     639    CTimer::get("XIOS").suspend(); 
     640  } 
     641 
     642  bool cxios_is_defined_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl) 
     643  { 
     644     CTimer::get("XIOS").resume(); 
     645     bool isDefined = domaingroup_hdl->ni_glo.hasInheritedValue(); 
     646     CTimer::get("XIOS").suspend(); 
     647     return isDefined; 
     648  } 
     649 
     650 
    627651  void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj) 
    628652  { 
    629      CTimer::get("XIOS").resume(); 
     653    CTimer::get("XIOS").resume(); 
    630654    domaingroup_hdl->nj.setValue(nj); 
    631      CTimer::get("XIOS").suspend(); 
    632   } 
    633    
     655    CTimer::get("XIOS").suspend(); 
     656  } 
     657 
    634658  void cxios_get_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int* nj) 
    635659  { 
     660    CTimer::get("XIOS").resume(); 
    636661    *nj = domaingroup_hdl->nj.getInheritedValue(); 
    637   } 
    638    
    639   bool cxios_is_defined_domaingroup_nj(domaingroup_Ptr domaingroup_hdl ) 
    640   { 
    641      CTimer::get("XIOS").resume(); 
    642     return domaingroup_hdl->nj.hasInheritedValue(); 
    643      CTimer::get("XIOS").suspend(); 
    644   } 
    645    
    646    
    647    
     662    CTimer::get("XIOS").suspend(); 
     663  } 
     664 
     665  bool cxios_is_defined_domaingroup_nj(domaingroup_Ptr domaingroup_hdl) 
     666  { 
     667     CTimer::get("XIOS").resume(); 
     668     bool isDefined = domaingroup_hdl->nj.hasInheritedValue(); 
     669     CTimer::get("XIOS").suspend(); 
     670     return isDefined; 
     671  } 
     672 
     673 
    648674  void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo) 
    649675  { 
    650      CTimer::get("XIOS").resume(); 
     676    CTimer::get("XIOS").resume(); 
    651677    domaingroup_hdl->nj_glo.setValue(nj_glo); 
    652      CTimer::get("XIOS").suspend(); 
    653   } 
    654    
     678    CTimer::get("XIOS").suspend(); 
     679  } 
     680 
    655681  void cxios_get_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int* nj_glo) 
    656682  { 
     683    CTimer::get("XIOS").resume(); 
    657684    *nj_glo = domaingroup_hdl->nj_glo.getInheritedValue(); 
    658   } 
    659    
    660   bool cxios_is_defined_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl ) 
    661   { 
    662      CTimer::get("XIOS").resume(); 
    663     return domaingroup_hdl->nj_glo.hasInheritedValue(); 
    664      CTimer::get("XIOS").suspend(); 
    665   } 
    666    
    667    
    668    
     685    CTimer::get("XIOS").suspend(); 
     686  } 
     687 
     688  bool cxios_is_defined_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl) 
     689  { 
     690     CTimer::get("XIOS").resume(); 
     691     bool isDefined = domaingroup_hdl->nj_glo.hasInheritedValue(); 
     692     CTimer::get("XIOS").suspend(); 
     693     return isDefined; 
     694  } 
     695 
     696 
    669697  void cxios_set_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl, int nvertex) 
    670698  { 
    671      CTimer::get("XIOS").resume(); 
     699    CTimer::get("XIOS").resume(); 
    672700    domaingroup_hdl->nvertex.setValue(nvertex); 
    673      CTimer::get("XIOS").suspend(); 
    674   } 
    675    
     701    CTimer::get("XIOS").suspend(); 
     702  } 
     703 
    676704  void cxios_get_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl, int* nvertex) 
    677705  { 
     706    CTimer::get("XIOS").resume(); 
    678707    *nvertex = domaingroup_hdl->nvertex.getInheritedValue(); 
    679   } 
    680    
    681   bool cxios_is_defined_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl ) 
    682   { 
    683      CTimer::get("XIOS").resume(); 
    684     return domaingroup_hdl->nvertex.hasInheritedValue(); 
    685      CTimer::get("XIOS").suspend(); 
    686   } 
    687    
    688    
    689    
     708    CTimer::get("XIOS").suspend(); 
     709  } 
     710 
     711  bool cxios_is_defined_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl) 
     712  { 
     713     CTimer::get("XIOS").resume(); 
     714     bool isDefined = domaingroup_hdl->nvertex.hasInheritedValue(); 
     715     CTimer::get("XIOS").suspend(); 
     716     return isDefined; 
     717  } 
     718 
     719 
    690720  void cxios_set_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, const char * standard_name, int standard_name_size) 
    691721  { 
    692722    std::string standard_name_str; 
    693     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    694      CTimer::get("XIOS").resume(); 
     723    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     724    CTimer::get("XIOS").resume(); 
    695725    domaingroup_hdl->standard_name.setValue(standard_name_str); 
    696      CTimer::get("XIOS").suspend(); 
    697   } 
    698    
     726    CTimer::get("XIOS").suspend(); 
     727  } 
     728 
    699729  void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size) 
    700730  { 
    701      CTimer::get("XIOS").resume(); 
    702     if(!string_copy(domaingroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    703       ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    704      CTimer::get("XIOS").suspend(); 
    705   } 
    706    
    707   bool cxios_is_defined_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl ) 
    708   { 
    709      CTimer::get("XIOS").resume(); 
    710     return domaingroup_hdl->standard_name.hasInheritedValue(); 
    711      CTimer::get("XIOS").suspend(); 
    712   } 
    713    
    714    
    715    
     731    CTimer::get("XIOS").resume(); 
     732    if (!string_copy(domaingroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size)) 
     733      ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short"); 
     734    CTimer::get("XIOS").suspend(); 
     735  } 
     736 
     737  bool cxios_is_defined_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl) 
     738  { 
     739     CTimer::get("XIOS").resume(); 
     740     bool isDefined = domaingroup_hdl->standard_name.hasInheritedValue(); 
     741     CTimer::get("XIOS").suspend(); 
     742     return isDefined; 
     743  } 
     744 
     745 
    716746  void cxios_set_domaingroup_type(domaingroup_Ptr domaingroup_hdl, const char * type, int type_size) 
    717747  { 
    718748    std::string type_str; 
    719     if(!cstr2string(type, type_size, type_str)) return; 
    720      CTimer::get("XIOS").resume(); 
     749    if (!cstr2string(type, type_size, type_str)) return; 
     750    CTimer::get("XIOS").resume(); 
    721751    domaingroup_hdl->type.fromString(type_str); 
    722      CTimer::get("XIOS").suspend(); 
    723   } 
    724    
     752    CTimer::get("XIOS").suspend(); 
     753  } 
     754 
    725755  void cxios_get_domaingroup_type(domaingroup_Ptr domaingroup_hdl, char * type, int type_size) 
    726756  { 
    727      CTimer::get("XIOS").resume(); 
    728     if(!string_copy(domaingroup_hdl->type.getInheritedStringValue(),type , type_size)) 
    729       ERROR("void cxios_get_domaingroup_type(domaingroup_Ptr domaingroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
    730      CTimer::get("XIOS").suspend(); 
    731   } 
    732    
    733   bool cxios_is_defined_domaingroup_type(domaingroup_Ptr domaingroup_hdl ) 
    734   { 
    735      CTimer::get("XIOS").resume(); 
    736     return domaingroup_hdl->type.hasInheritedValue(); 
    737      CTimer::get("XIOS").suspend(); 
    738   } 
    739    
    740    
    741    
     757    CTimer::get("XIOS").resume(); 
     758    if (!string_copy(domaingroup_hdl->type.getInheritedStringValue(), type, type_size)) 
     759      ERROR("void cxios_get_domaingroup_type(domaingroup_Ptr domaingroup_hdl, char * type, int type_size)", << "Input string is too short"); 
     760    CTimer::get("XIOS").suspend(); 
     761  } 
     762 
     763  bool cxios_is_defined_domaingroup_type(domaingroup_Ptr domaingroup_hdl) 
     764  { 
     765     CTimer::get("XIOS").resume(); 
     766     bool isDefined = domaingroup_hdl->type.hasInheritedValue(); 
     767     CTimer::get("XIOS").suspend(); 
     768     return isDefined; 
     769  } 
     770 
     771 
    742772  void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin) 
    743773  { 
    744      CTimer::get("XIOS").resume(); 
     774    CTimer::get("XIOS").resume(); 
    745775    domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    746      CTimer::get("XIOS").suspend(); 
    747   } 
    748    
     776    CTimer::get("XIOS").suspend(); 
     777  } 
     778 
    749779  void cxios_get_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin) 
    750780  { 
     781    CTimer::get("XIOS").resume(); 
    751782    *zoom_ibegin = domaingroup_hdl->zoom_ibegin.getInheritedValue(); 
    752   } 
    753    
    754   bool cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl ) 
    755   { 
    756      CTimer::get("XIOS").resume(); 
    757     return domaingroup_hdl->zoom_ibegin.hasInheritedValue(); 
    758      CTimer::get("XIOS").suspend(); 
    759   } 
    760    
    761    
    762    
     783    CTimer::get("XIOS").suspend(); 
     784  } 
     785 
     786  bool cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl) 
     787  { 
     788     CTimer::get("XIOS").resume(); 
     789     bool isDefined = domaingroup_hdl->zoom_ibegin.hasInheritedValue(); 
     790     CTimer::get("XIOS").suspend(); 
     791     return isDefined; 
     792  } 
     793 
     794 
    763795  void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc) 
    764796  { 
    765      CTimer::get("XIOS").resume(); 
     797    CTimer::get("XIOS").resume(); 
    766798    domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    767      CTimer::get("XIOS").suspend(); 
    768   } 
    769    
     799    CTimer::get("XIOS").suspend(); 
     800  } 
     801 
    770802  void cxios_get_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin_loc) 
    771803  { 
     804    CTimer::get("XIOS").resume(); 
    772805    *zoom_ibegin_loc = domaingroup_hdl->zoom_ibegin_loc.getInheritedValue(); 
    773   } 
    774    
    775   bool cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl ) 
    776   { 
    777      CTimer::get("XIOS").resume(); 
    778     return domaingroup_hdl->zoom_ibegin_loc.hasInheritedValue(); 
    779      CTimer::get("XIOS").suspend(); 
    780   } 
    781    
    782    
    783    
     806    CTimer::get("XIOS").suspend(); 
     807  } 
     808 
     809  bool cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl) 
     810  { 
     811     CTimer::get("XIOS").resume(); 
     812     bool isDefined = domaingroup_hdl->zoom_ibegin_loc.hasInheritedValue(); 
     813     CTimer::get("XIOS").suspend(); 
     814     return isDefined; 
     815  } 
     816 
     817 
    784818  void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin) 
    785819  { 
    786      CTimer::get("XIOS").resume(); 
     820    CTimer::get("XIOS").resume(); 
    787821    domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    788      CTimer::get("XIOS").suspend(); 
    789   } 
    790    
     822    CTimer::get("XIOS").suspend(); 
     823  } 
     824 
    791825  void cxios_get_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin) 
    792826  { 
     827    CTimer::get("XIOS").resume(); 
    793828    *zoom_jbegin = domaingroup_hdl->zoom_jbegin.getInheritedValue(); 
    794   } 
    795    
    796   bool cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl ) 
    797   { 
    798      CTimer::get("XIOS").resume(); 
    799     return domaingroup_hdl->zoom_jbegin.hasInheritedValue(); 
    800      CTimer::get("XIOS").suspend(); 
    801   } 
    802    
    803    
    804    
     829    CTimer::get("XIOS").suspend(); 
     830  } 
     831 
     832  bool cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl) 
     833  { 
     834     CTimer::get("XIOS").resume(); 
     835     bool isDefined = domaingroup_hdl->zoom_jbegin.hasInheritedValue(); 
     836     CTimer::get("XIOS").suspend(); 
     837     return isDefined; 
     838  } 
     839 
     840 
    805841  void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc) 
    806842  { 
    807      CTimer::get("XIOS").resume(); 
     843    CTimer::get("XIOS").resume(); 
    808844    domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    809      CTimer::get("XIOS").suspend(); 
    810   } 
    811    
     845    CTimer::get("XIOS").suspend(); 
     846  } 
     847 
    812848  void cxios_get_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin_loc) 
    813849  { 
     850    CTimer::get("XIOS").resume(); 
    814851    *zoom_jbegin_loc = domaingroup_hdl->zoom_jbegin_loc.getInheritedValue(); 
    815   } 
    816    
    817   bool cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl ) 
    818   { 
    819      CTimer::get("XIOS").resume(); 
    820     return domaingroup_hdl->zoom_jbegin_loc.hasInheritedValue(); 
    821      CTimer::get("XIOS").suspend(); 
    822   } 
    823    
    824    
    825    
     852    CTimer::get("XIOS").suspend(); 
     853  } 
     854 
     855  bool cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl) 
     856  { 
     857     CTimer::get("XIOS").resume(); 
     858     bool isDefined = domaingroup_hdl->zoom_jbegin_loc.hasInheritedValue(); 
     859     CTimer::get("XIOS").suspend(); 
     860     return isDefined; 
     861  } 
     862 
     863 
    826864  void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni) 
    827865  { 
    828      CTimer::get("XIOS").resume(); 
     866    CTimer::get("XIOS").resume(); 
    829867    domaingroup_hdl->zoom_ni.setValue(zoom_ni); 
    830      CTimer::get("XIOS").suspend(); 
    831   } 
    832    
     868    CTimer::get("XIOS").suspend(); 
     869  } 
     870 
    833871  void cxios_get_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int* zoom_ni) 
    834872  { 
     873    CTimer::get("XIOS").resume(); 
    835874    *zoom_ni = domaingroup_hdl->zoom_ni.getInheritedValue(); 
    836   } 
    837    
    838   bool cxios_is_defined_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl ) 
    839   { 
    840      CTimer::get("XIOS").resume(); 
    841     return domaingroup_hdl->zoom_ni.hasInheritedValue(); 
    842      CTimer::get("XIOS").suspend(); 
    843   } 
    844    
    845    
    846    
     875    CTimer::get("XIOS").suspend(); 
     876  } 
     877 
     878  bool cxios_is_defined_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl) 
     879  { 
     880     CTimer::get("XIOS").resume(); 
     881     bool isDefined = domaingroup_hdl->zoom_ni.hasInheritedValue(); 
     882     CTimer::get("XIOS").suspend(); 
     883     return isDefined; 
     884  } 
     885 
     886 
    847887  void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc) 
    848888  { 
    849      CTimer::get("XIOS").resume(); 
     889    CTimer::get("XIOS").resume(); 
    850890    domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    851      CTimer::get("XIOS").suspend(); 
    852   } 
    853    
     891    CTimer::get("XIOS").suspend(); 
     892  } 
     893 
    854894  void cxios_get_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ni_loc) 
    855895  { 
     896    CTimer::get("XIOS").resume(); 
    856897    *zoom_ni_loc = domaingroup_hdl->zoom_ni_loc.getInheritedValue(); 
    857   } 
    858    
    859   bool cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl ) 
    860   { 
    861      CTimer::get("XIOS").resume(); 
    862     return domaingroup_hdl->zoom_ni_loc.hasInheritedValue(); 
    863      CTimer::get("XIOS").suspend(); 
    864   } 
    865    
    866    
    867    
     898    CTimer::get("XIOS").suspend(); 
     899  } 
     900 
     901  bool cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl) 
     902  { 
     903     CTimer::get("XIOS").resume(); 
     904     bool isDefined = domaingroup_hdl->zoom_ni_loc.hasInheritedValue(); 
     905     CTimer::get("XIOS").suspend(); 
     906     return isDefined; 
     907  } 
     908 
     909 
    868910  void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj) 
    869911  { 
    870      CTimer::get("XIOS").resume(); 
     912    CTimer::get("XIOS").resume(); 
    871913    domaingroup_hdl->zoom_nj.setValue(zoom_nj); 
    872      CTimer::get("XIOS").suspend(); 
    873   } 
    874    
     914    CTimer::get("XIOS").suspend(); 
     915  } 
     916 
    875917  void cxios_get_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int* zoom_nj) 
    876918  { 
     919    CTimer::get("XIOS").resume(); 
    877920    *zoom_nj = domaingroup_hdl->zoom_nj.getInheritedValue(); 
    878   } 
    879    
    880   bool cxios_is_defined_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl ) 
    881   { 
    882      CTimer::get("XIOS").resume(); 
    883     return domaingroup_hdl->zoom_nj.hasInheritedValue(); 
    884      CTimer::get("XIOS").suspend(); 
    885   } 
    886    
    887    
    888    
     921    CTimer::get("XIOS").suspend(); 
     922  } 
     923 
     924  bool cxios_is_defined_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl) 
     925  { 
     926     CTimer::get("XIOS").resume(); 
     927     bool isDefined = domaingroup_hdl->zoom_nj.hasInheritedValue(); 
     928     CTimer::get("XIOS").suspend(); 
     929     return isDefined; 
     930  } 
     931 
     932 
    889933  void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc) 
    890934  { 
    891      CTimer::get("XIOS").resume(); 
     935    CTimer::get("XIOS").resume(); 
    892936    domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    893      CTimer::get("XIOS").suspend(); 
    894   } 
    895    
     937    CTimer::get("XIOS").suspend(); 
     938  } 
     939 
    896940  void cxios_get_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_nj_loc) 
    897941  { 
     942    CTimer::get("XIOS").resume(); 
    898943    *zoom_nj_loc = domaingroup_hdl->zoom_nj_loc.getInheritedValue(); 
    899   } 
    900    
    901   bool cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl ) 
    902   { 
    903      CTimer::get("XIOS").resume(); 
    904     return domaingroup_hdl->zoom_nj_loc.hasInheritedValue(); 
    905      CTimer::get("XIOS").suspend(); 
    906   } 
    907    
    908    
    909    
    910    
     944    CTimer::get("XIOS").suspend(); 
     945  } 
     946 
     947  bool cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl) 
     948  { 
     949     CTimer::get("XIOS").resume(); 
     950     bool isDefined = domaingroup_hdl->zoom_nj_loc.hasInheritedValue(); 
     951     CTimer::get("XIOS").suspend(); 
     952     return isDefined; 
     953  } 
    911954} 

  • 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} 

  • 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} 

  • XIOS/trunk/src/interface/c_attr/icfile_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::CFile*  file_Ptr; 
    19    
     18  typedef xios::CFile* file_Ptr; 
     19 
    2020  void cxios_set_file_append(file_Ptr file_hdl, bool append) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    file_hdl->append.setValue(append); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_file_append(file_Ptr file_hdl, bool* append) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *append = file_hdl->append.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_file_append(file_Ptr file_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return file_hdl->append.hasInheritedValue(); 
    36      CTimer::get("XIOS").suspend(); 
    37   } 
    38    
    39    
    40    
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_file_append(file_Ptr file_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = file_hdl->append.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_file_description(file_Ptr file_hdl, const char * description, int description_size) 
    4244  { 
    4345    std::string description_str; 
    44     if(!cstr2string(description, description_size, description_str)) return; 
    45      CTimer::get("XIOS").resume(); 
     46    if (!cstr2string(description, description_size, description_str)) return; 
     47    CTimer::get("XIOS").resume(); 
    4648    file_hdl->description.setValue(description_str); 
    47      CTimer::get("XIOS").suspend(); 
    48   } 
    49    
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
    5052  void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size) 
    5153  { 
    52      CTimer::get("XIOS").resume(); 
    53     if(!string_copy(file_hdl->description.getInheritedValue(),description , description_size)) 
    54       ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", <<"Input string is to short"); 
    55      CTimer::get("XIOS").suspend(); 
    56   } 
    57    
    58   bool cxios_is_defined_file_description(file_Ptr file_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return file_hdl->description.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(file_hdl->description.getInheritedValue(), description, description_size)) 
     56      ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_file_description(file_Ptr file_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = file_hdl->description.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_file_enabled(file_Ptr file_hdl, bool enabled) 
    6870  { 
    69      CTimer::get("XIOS").resume(); 
     71    CTimer::get("XIOS").resume(); 
    7072    file_hdl->enabled.setValue(enabled); 
    71      CTimer::get("XIOS").suspend(); 
    72   } 
    73    
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
    7476  void cxios_get_file_enabled(file_Ptr file_hdl, bool* enabled) 
    7577  { 
     78    CTimer::get("XIOS").resume(); 
    7679    *enabled = file_hdl->enabled.getInheritedValue(); 
    77   } 
    78    
    79   bool cxios_is_defined_file_enabled(file_Ptr file_hdl ) 
    80   { 
    81      CTimer::get("XIOS").resume(); 
    82     return file_hdl->enabled.hasInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85    
    86    
    87    
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_file_enabled(file_Ptr file_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = file_hdl->enabled.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
     90 
     91 
    8892  void cxios_set_file_format(file_Ptr file_hdl, const char * format, int format_size) 
    8993  { 
    9094    std::string format_str; 
    91     if(!cstr2string(format, format_size, format_str)) return; 
    92      CTimer::get("XIOS").resume(); 
     95    if (!cstr2string(format, format_size, format_str)) return; 
     96    CTimer::get("XIOS").resume(); 
    9397    file_hdl->format.fromString(format_str); 
    94      CTimer::get("XIOS").suspend(); 
    95   } 
    96    
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
    97101  void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size) 
    98102  { 
    99      CTimer::get("XIOS").resume(); 
    100     if(!string_copy(file_hdl->format.getInheritedStringValue(),format , format_size)) 
    101       ERROR("void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size)", <<"Input string is to short"); 
    102      CTimer::get("XIOS").suspend(); 
    103   } 
    104    
    105   bool cxios_is_defined_file_format(file_Ptr file_hdl ) 
    106   { 
    107      CTimer::get("XIOS").resume(); 
    108     return file_hdl->format.hasInheritedValue(); 
    109      CTimer::get("XIOS").suspend(); 
    110   } 
    111    
    112    
    113    
     103    CTimer::get("XIOS").resume(); 
     104    if (!string_copy(file_hdl->format.getInheritedStringValue(), format, format_size)) 
     105      ERROR("void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size)", << "Input string is too short"); 
     106    CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_file_format(file_Ptr file_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = file_hdl->format.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    114118  void cxios_set_file_min_digits(file_Ptr file_hdl, int min_digits) 
    115119  { 
    116      CTimer::get("XIOS").resume(); 
     120    CTimer::get("XIOS").resume(); 
    117121    file_hdl->min_digits.setValue(min_digits); 
    118      CTimer::get("XIOS").suspend(); 
    119   } 
    120    
     122    CTimer::get("XIOS").suspend(); 
     123  } 
     124 
    121125  void cxios_get_file_min_digits(file_Ptr file_hdl, int* min_digits) 
    122126  { 
     127    CTimer::get("XIOS").resume(); 
    123128    *min_digits = file_hdl->min_digits.getInheritedValue(); 
    124   } 
    125    
    126   bool cxios_is_defined_file_min_digits(file_Ptr file_hdl ) 
    127   { 
    128      CTimer::get("XIOS").resume(); 
    129     return file_hdl->min_digits.hasInheritedValue(); 
    130      CTimer::get("XIOS").suspend(); 
    131   } 
    132    
    133    
    134    
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_file_min_digits(file_Ptr file_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = file_hdl->min_digits.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    135141  void cxios_set_file_name(file_Ptr file_hdl, const char * name, int name_size) 
    136142  { 
    137143    std::string name_str; 
    138     if(!cstr2string(name, name_size, name_str)) return; 
    139      CTimer::get("XIOS").resume(); 
     144    if (!cstr2string(name, name_size, name_str)) return; 
     145    CTimer::get("XIOS").resume(); 
    140146    file_hdl->name.setValue(name_str); 
    141      CTimer::get("XIOS").suspend(); 
    142   } 
    143    
     147    CTimer::get("XIOS").suspend(); 
     148  } 
     149 
    144150  void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size) 
    145151  { 
    146      CTimer::get("XIOS").resume(); 
    147     if(!string_copy(file_hdl->name.getInheritedValue(),name , name_size)) 
    148       ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", <<"Input string is to short"); 
    149      CTimer::get("XIOS").suspend(); 
    150   } 
    151    
    152   bool cxios_is_defined_file_name(file_Ptr file_hdl ) 
    153   { 
    154      CTimer::get("XIOS").resume(); 
    155     return file_hdl->name.hasInheritedValue(); 
    156      CTimer::get("XIOS").suspend(); 
    157   } 
    158    
    159    
    160    
     152    CTimer::get("XIOS").resume(); 
     153    if (!string_copy(file_hdl->name.getInheritedValue(), name, name_size)) 
     154      ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", << "Input string is too short"); 
     155    CTimer::get("XIOS").suspend(); 
     156  } 
     157 
     158  bool cxios_is_defined_file_name(file_Ptr file_hdl) 
     159  { 
     160     CTimer::get("XIOS").resume(); 
     161     bool isDefined = file_hdl->name.hasInheritedValue(); 
     162     CTimer::get("XIOS").suspend(); 
     163     return isDefined; 
     164  } 
     165 
     166 
    161167  void cxios_set_file_name_suffix(file_Ptr file_hdl, const char * name_suffix, int name_suffix_size) 
    162168  { 
    163169    std::string name_suffix_str; 
    164     if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
    165      CTimer::get("XIOS").resume(); 
     170    if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
     171    CTimer::get("XIOS").resume(); 
    166172    file_hdl->name_suffix.setValue(name_suffix_str); 
    167      CTimer::get("XIOS").suspend(); 
    168   } 
    169    
     173    CTimer::get("XIOS").suspend(); 
     174  } 
     175 
    170176  void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size) 
    171177  { 
    172      CTimer::get("XIOS").resume(); 
    173     if(!string_copy(file_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size)) 
    174       ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
    175      CTimer::get("XIOS").suspend(); 
    176   } 
    177    
    178   bool cxios_is_defined_file_name_suffix(file_Ptr file_hdl ) 
    179   { 
    180      CTimer::get("XIOS").resume(); 
    181     return file_hdl->name_suffix.hasInheritedValue(); 
    182      CTimer::get("XIOS").suspend(); 
    183   } 
    184    
    185    
    186    
     178    CTimer::get("XIOS").resume(); 
     179    if (!string_copy(file_hdl->name_suffix.getInheritedValue(), name_suffix, name_suffix_size)) 
     180      ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", << "Input string is too short"); 
     181    CTimer::get("XIOS").suspend(); 
     182  } 
     183 
     184  bool cxios_is_defined_file_name_suffix(file_Ptr file_hdl) 
     185  { 
     186     CTimer::get("XIOS").resume(); 
     187     bool isDefined = file_hdl->name_suffix.hasInheritedValue(); 
     188     CTimer::get("XIOS").suspend(); 
     189     return isDefined; 
     190  } 
     191 
     192 
    187193  void cxios_set_file_output_freq(file_Ptr file_hdl, cxios_duration output_freq_c) 
    188194  { 
    … …  
    199205    CTimer::get("XIOS").suspend(); 
    200206  } 
    201    
     207 
    202208  void cxios_get_file_output_freq(file_Ptr file_hdl, cxios_duration* output_freq_c) 
    203209  { 
    … …  
    213219    CTimer::get("XIOS").suspend(); 
    214220  } 
    215    
    216   bool cxios_is_defined_file_output_freq(file_Ptr file_hdl ) 
    217   { 
    218      CTimer::get("XIOS").resume(); 
    219     return file_hdl->output_freq.hasInheritedValue(); 
    220      CTimer::get("XIOS").suspend(); 
    221   } 
    222    
    223    
    224    
     221 
     222  bool cxios_is_defined_file_output_freq(file_Ptr file_hdl) 
     223  { 
     224     CTimer::get("XIOS").resume(); 
     225     bool isDefined = file_hdl->output_freq.hasInheritedValue(); 
     226     CTimer::get("XIOS").suspend(); 
     227     return isDefined; 
     228  } 
     229 
     230 
    225231  void cxios_set_file_output_level(file_Ptr file_hdl, int output_level) 
    226232  { 
    227      CTimer::get("XIOS").resume(); 
     233    CTimer::get("XIOS").resume(); 
    228234    file_hdl->output_level.setValue(output_level); 
    229      CTimer::get("XIOS").suspend(); 
    230   } 
    231    
     235    CTimer::get("XIOS").suspend(); 
     236  } 
     237 
    232238  void cxios_get_file_output_level(file_Ptr file_hdl, int* output_level) 
    233239  { 
     240    CTimer::get("XIOS").resume(); 
    234241    *output_level = file_hdl->output_level.getInheritedValue(); 
    235   } 
    236    
    237   bool cxios_is_defined_file_output_level(file_Ptr file_hdl ) 
    238   { 
    239      CTimer::get("XIOS").resume(); 
    240     return file_hdl->output_level.hasInheritedValue(); 
    241      CTimer::get("XIOS").suspend(); 
    242   } 
    243    
    244    
    245    
     242    CTimer::get("XIOS").suspend(); 
     243  } 
     244 
     245  bool cxios_is_defined_file_output_level(file_Ptr file_hdl) 
     246  { 
     247     CTimer::get("XIOS").resume(); 
     248     bool isDefined = file_hdl->output_level.hasInheritedValue(); 
     249     CTimer::get("XIOS").suspend(); 
     250     return isDefined; 
     251  } 
     252 
     253 
    246254  void cxios_set_file_par_access(file_Ptr file_hdl, const char * par_access, int par_access_size) 
    247255  { 
    248256    std::string par_access_str; 
    249     if(!cstr2string(par_access, par_access_size, par_access_str)) return; 
    250      CTimer::get("XIOS").resume(); 
     257    if (!cstr2string(par_access, par_access_size, par_access_str)) return; 
     258    CTimer::get("XIOS").resume(); 
    251259    file_hdl->par_access.fromString(par_access_str); 
    252      CTimer::get("XIOS").suspend(); 
    253   } 
    254    
     260    CTimer::get("XIOS").suspend(); 
     261  } 
     262 
    255263  void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size) 
    256264  { 
    257      CTimer::get("XIOS").resume(); 
    258     if(!string_copy(file_hdl->par_access.getInheritedStringValue(),par_access , par_access_size)) 
    259       ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
    260      CTimer::get("XIOS").suspend(); 
    261   } 
    262    
    263   bool cxios_is_defined_file_par_access(file_Ptr file_hdl ) 
    264   { 
    265      CTimer::get("XIOS").resume(); 
    266     return file_hdl->par_access.hasInheritedValue(); 
    267      CTimer::get("XIOS").suspend(); 
    268   } 
    269    
    270    
    271    
     265    CTimer::get("XIOS").resume(); 
     266    if (!string_copy(file_hdl->par_access.getInheritedStringValue(), par_access, par_access_size)) 
     267      ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", << "Input string is too short"); 
     268    CTimer::get("XIOS").suspend(); 
     269  } 
     270 
     271  bool cxios_is_defined_file_par_access(file_Ptr file_hdl) 
     272  { 
     273     CTimer::get("XIOS").resume(); 
     274     bool isDefined = file_hdl->par_access.hasInheritedValue(); 
     275     CTimer::get("XIOS").suspend(); 
     276     return isDefined; 
     277  } 
     278 
     279 
    272280  void cxios_set_file_split_freq(file_Ptr file_hdl, cxios_duration split_freq_c) 
    273281  { 
    … …  
    284292    CTimer::get("XIOS").suspend(); 
    285293  } 
    286    
     294 
    287295  void cxios_get_file_split_freq(file_Ptr file_hdl, cxios_duration* split_freq_c) 
    288296  { 
    … …  
    298306    CTimer::get("XIOS").suspend(); 
    299307  } 
    300    
    301   bool cxios_is_defined_file_split_freq(file_Ptr file_hdl ) 
    302   { 
    303      CTimer::get("XIOS").resume(); 
    304     return file_hdl->split_freq.hasInheritedValue(); 
    305      CTimer::get("XIOS").suspend(); 
    306   } 
    307    
    308    
    309    
     308 
     309  bool cxios_is_defined_file_split_freq(file_Ptr file_hdl) 
     310  { 
     311     CTimer::get("XIOS").resume(); 
     312     bool isDefined = file_hdl->split_freq.hasInheritedValue(); 
     313     CTimer::get("XIOS").suspend(); 
     314     return isDefined; 
     315  } 
     316 
     317 
    310318  void cxios_set_file_split_freq_format(file_Ptr file_hdl, const char * split_freq_format, int split_freq_format_size) 
    311319  { 
    312320    std::string split_freq_format_str; 
    313     if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
    314      CTimer::get("XIOS").resume(); 
     321    if (!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
     322    CTimer::get("XIOS").resume(); 
    315323    file_hdl->split_freq_format.setValue(split_freq_format_str); 
    316      CTimer::get("XIOS").suspend(); 
    317   } 
    318    
     324    CTimer::get("XIOS").suspend(); 
     325  } 
     326 
    319327  void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size) 
    320328  { 
    321      CTimer::get("XIOS").resume(); 
    322     if(!string_copy(file_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size)) 
    323       ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short"); 
    324      CTimer::get("XIOS").suspend(); 
    325   } 
    326    
    327   bool cxios_is_defined_file_split_freq_format(file_Ptr file_hdl ) 
    328   { 
    329      CTimer::get("XIOS").resume(); 
    330     return file_hdl->split_freq_format.hasInheritedValue(); 
    331      CTimer::get("XIOS").suspend(); 
    332   } 
    333    
    334    
    335    
     329    CTimer::get("XIOS").resume(); 
     330    if (!string_copy(file_hdl->split_freq_format.getInheritedValue(), split_freq_format, split_freq_format_size)) 
     331      ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", << "Input string is too short"); 
     332    CTimer::get("XIOS").suspend(); 
     333  } 
     334 
     335  bool cxios_is_defined_file_split_freq_format(file_Ptr file_hdl) 
     336  { 
     337     CTimer::get("XIOS").resume(); 
     338     bool isDefined = file_hdl->split_freq_format.hasInheritedValue(); 
     339     CTimer::get("XIOS").suspend(); 
     340     return isDefined; 
     341  } 
     342 
     343 
    336344  void cxios_set_file_sync_freq(file_Ptr file_hdl, cxios_duration sync_freq_c) 
    337345  { 
    … …  
    348356    CTimer::get("XIOS").suspend(); 
    349357  } 
    350    
     358 
    351359  void cxios_get_file_sync_freq(file_Ptr file_hdl, cxios_duration* sync_freq_c) 
    352360  { 
    … …  
    362370    CTimer::get("XIOS").suspend(); 
    363371  } 
    364    
    365   bool cxios_is_defined_file_sync_freq(file_Ptr file_hdl ) 
    366   { 
    367      CTimer::get("XIOS").resume(); 
    368     return file_hdl->sync_freq.hasInheritedValue(); 
    369      CTimer::get("XIOS").suspend(); 
    370   } 
    371    
    372    
    373    
     372 
     373  bool cxios_is_defined_file_sync_freq(file_Ptr file_hdl) 
     374  { 
     375     CTimer::get("XIOS").resume(); 
     376     bool isDefined = file_hdl->sync_freq.hasInheritedValue(); 
     377     CTimer::get("XIOS").suspend(); 
     378     return isDefined; 
     379  } 
     380 
     381 
    374382  void cxios_set_file_type(file_Ptr file_hdl, const char * type, int type_size) 
    375383  { 
    376384    std::string type_str; 
    377     if(!cstr2string(type, type_size, type_str)) return; 
    378      CTimer::get("XIOS").resume(); 
     385    if (!cstr2string(type, type_size, type_str)) return; 
     386    CTimer::get("XIOS").resume(); 
    379387    file_hdl->type.fromString(type_str); 
    380      CTimer::get("XIOS").suspend(); 
    381   } 
    382    
     388    CTimer::get("XIOS").suspend(); 
     389  } 
     390 
    383391  void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size) 
    384392  { 
    385      CTimer::get("XIOS").resume(); 
    386     if(!string_copy(file_hdl->type.getInheritedStringValue(),type , type_size)) 
    387       ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short"); 
    388      CTimer::get("XIOS").suspend(); 
    389   } 
    390    
    391   bool cxios_is_defined_file_type(file_Ptr file_hdl ) 
    392   { 
    393      CTimer::get("XIOS").resume(); 
    394     return file_hdl->type.hasInheritedValue(); 
    395      CTimer::get("XIOS").suspend(); 
    396   } 
    397    
    398    
    399    
    400    
     393    CTimer::get("XIOS").resume(); 
     394    if (!string_copy(file_hdl->type.getInheritedStringValue(), type, type_size)) 
     395      ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", << "Input string is too short"); 
     396    CTimer::get("XIOS").suspend(); 
     397  } 
     398 
     399  bool cxios_is_defined_file_type(file_Ptr file_hdl) 
     400  { 
     401     CTimer::get("XIOS").resume(); 
     402     bool isDefined = file_hdl->type.hasInheritedValue(); 
     403     CTimer::get("XIOS").suspend(); 
     404     return isDefined; 
     405  } 
    401406} 

  • XIOS/trunk/src/interface/c_attr/icfilegroup_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::CFileGroup*  filegroup_Ptr; 
    19    
     18  typedef xios::CFileGroup* filegroup_Ptr; 
     19 
    2020  void cxios_set_filegroup_append(filegroup_Ptr filegroup_hdl, bool append) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    filegroup_hdl->append.setValue(append); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_filegroup_append(filegroup_Ptr filegroup_hdl, bool* append) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *append = filegroup_hdl->append.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_filegroup_append(filegroup_Ptr filegroup_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return filegroup_hdl->append.hasInheritedValue(); 
    36      CTimer::get("XIOS").suspend(); 
    37   } 
    38    
    39    
    40    
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_filegroup_append(filegroup_Ptr filegroup_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = filegroup_hdl->append.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size) 
    4244  { 
    4345    std::string description_str; 
    44     if(!cstr2string(description, description_size, description_str)) return; 
    45      CTimer::get("XIOS").resume(); 
     46    if (!cstr2string(description, description_size, description_str)) return; 
     47    CTimer::get("XIOS").resume(); 
    4648    filegroup_hdl->description.setValue(description_str); 
    47      CTimer::get("XIOS").suspend(); 
    48   } 
    49    
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
    5052  void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size) 
    5153  { 
    52      CTimer::get("XIOS").resume(); 
    53     if(!string_copy(filegroup_hdl->description.getInheritedValue(),description , description_size)) 
    54       ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
    55      CTimer::get("XIOS").suspend(); 
    56   } 
    57    
    58   bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return filegroup_hdl->description.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(filegroup_hdl->description.getInheritedValue(), description, description_size)) 
     56      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = filegroup_hdl->description.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled) 
    6870  { 
    69      CTimer::get("XIOS").resume(); 
     71    CTimer::get("XIOS").resume(); 
    7072    filegroup_hdl->enabled.setValue(enabled); 
    71      CTimer::get("XIOS").suspend(); 
    72   } 
    73    
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
    7476  void cxios_get_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool* enabled) 
    7577  { 
     78    CTimer::get("XIOS").resume(); 
    7679    *enabled = filegroup_hdl->enabled.getInheritedValue(); 
    77   } 
    78    
    79   bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl ) 
    80   { 
    81      CTimer::get("XIOS").resume(); 
    82     return filegroup_hdl->enabled.hasInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85    
    86    
    87    
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = filegroup_hdl->enabled.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
     90 
     91 
    8892  void cxios_set_filegroup_format(filegroup_Ptr filegroup_hdl, const char * format, int format_size) 
    8993  { 
    9094    std::string format_str; 
    91     if(!cstr2string(format, format_size, format_str)) return; 
    92      CTimer::get("XIOS").resume(); 
     95    if (!cstr2string(format, format_size, format_str)) return; 
     96    CTimer::get("XIOS").resume(); 
    9397    filegroup_hdl->format.fromString(format_str); 
    94      CTimer::get("XIOS").suspend(); 
    95   } 
    96    
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
    97101  void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size) 
    98102  { 
    99      CTimer::get("XIOS").resume(); 
    100     if(!string_copy(filegroup_hdl->format.getInheritedStringValue(),format , format_size)) 
    101       ERROR("void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)", <<"Input string is to short"); 
    102      CTimer::get("XIOS").suspend(); 
    103   } 
    104    
    105   bool cxios_is_defined_filegroup_format(filegroup_Ptr filegroup_hdl ) 
    106   { 
    107      CTimer::get("XIOS").resume(); 
    108     return filegroup_hdl->format.hasInheritedValue(); 
    109      CTimer::get("XIOS").suspend(); 
    110   } 
    111    
    112    
    113    
     103    CTimer::get("XIOS").resume(); 
     104    if (!string_copy(filegroup_hdl->format.getInheritedStringValue(), format, format_size)) 
     105      ERROR("void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)", << "Input string is too short"); 
     106    CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_filegroup_format(filegroup_Ptr filegroup_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = filegroup_hdl->format.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    114118  void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size) 
    115119  { 
    116120    std::string group_ref_str; 
    117     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    118      CTimer::get("XIOS").resume(); 
     121    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     122    CTimer::get("XIOS").resume(); 
    119123    filegroup_hdl->group_ref.setValue(group_ref_str); 
    120      CTimer::get("XIOS").suspend(); 
    121   } 
    122    
     124    CTimer::get("XIOS").suspend(); 
     125  } 
     126 
    123127  void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size) 
    124128  { 
    125      CTimer::get("XIOS").resume(); 
    126     if(!string_copy(filegroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    127       ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    128      CTimer::get("XIOS").suspend(); 
    129   } 
    130    
    131   bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl ) 
    132   { 
    133      CTimer::get("XIOS").resume(); 
    134     return filegroup_hdl->group_ref.hasInheritedValue(); 
    135      CTimer::get("XIOS").suspend(); 
    136   } 
    137    
    138    
    139    
     129    CTimer::get("XIOS").resume(); 
     130    if (!string_copy(filegroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     131      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     132    CTimer::get("XIOS").suspend(); 
     133  } 
     134 
     135  bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl) 
     136  { 
     137     CTimer::get("XIOS").resume(); 
     138     bool isDefined = filegroup_hdl->group_ref.hasInheritedValue(); 
     139     CTimer::get("XIOS").suspend(); 
     140     return isDefined; 
     141  } 
     142 
     143 
    140144  void cxios_set_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int min_digits) 
    141145  { 
    142      CTimer::get("XIOS").resume(); 
     146    CTimer::get("XIOS").resume(); 
    143147    filegroup_hdl->min_digits.setValue(min_digits); 
    144      CTimer::get("XIOS").suspend(); 
    145   } 
    146    
     148    CTimer::get("XIOS").suspend(); 
     149  } 
     150 
    147151  void cxios_get_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int* min_digits) 
    148152  { 
     153    CTimer::get("XIOS").resume(); 
    149154    *min_digits = filegroup_hdl->min_digits.getInheritedValue(); 
    150   } 
    151    
    152   bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl ) 
    153   { 
    154      CTimer::get("XIOS").resume(); 
    155     return filegroup_hdl->min_digits.hasInheritedValue(); 
    156      CTimer::get("XIOS").suspend(); 
    157   } 
    158    
    159    
    160    
     155    CTimer::get("XIOS").suspend(); 
     156  } 
     157 
     158  bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl) 
     159  { 
     160     CTimer::get("XIOS").resume(); 
     161     bool isDefined = filegroup_hdl->min_digits.hasInheritedValue(); 
     162     CTimer::get("XIOS").suspend(); 
     163     return isDefined; 
     164  } 
     165 
     166 
    161167  void cxios_set_filegroup_name(filegroup_Ptr filegroup_hdl, const char * name, int name_size) 
    162168  { 
    163169    std::string name_str; 
    164     if(!cstr2string(name, name_size, name_str)) return; 
    165      CTimer::get("XIOS").resume(); 
     170    if (!cstr2string(name, name_size, name_str)) return; 
     171    CTimer::get("XIOS").resume(); 
    166172    filegroup_hdl->name.setValue(name_str); 
    167      CTimer::get("XIOS").suspend(); 
    168   } 
    169    
     173    CTimer::get("XIOS").suspend(); 
     174  } 
     175 
    170176  void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size) 
    171177  { 
    172      CTimer::get("XIOS").resume(); 
    173     if(!string_copy(filegroup_hdl->name.getInheritedValue(),name , name_size)) 
    174       ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    175      CTimer::get("XIOS").suspend(); 
    176   } 
    177    
    178   bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl ) 
    179   { 
    180      CTimer::get("XIOS").resume(); 
    181     return filegroup_hdl->name.hasInheritedValue(); 
    182      CTimer::get("XIOS").suspend(); 
    183   } 
    184    
    185    
    186    
     178    CTimer::get("XIOS").resume(); 
     179    if (!string_copy(filegroup_hdl->name.getInheritedValue(), name, name_size)) 
     180      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     181    CTimer::get("XIOS").suspend(); 
     182  } 
     183 
     184  bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl) 
     185  { 
     186     CTimer::get("XIOS").resume(); 
     187     bool isDefined = filegroup_hdl->name.hasInheritedValue(); 
     188     CTimer::get("XIOS").suspend(); 
     189     return isDefined; 
     190  } 
     191 
     192 
    187193  void cxios_set_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, const char * name_suffix, int name_suffix_size) 
    188194  { 
    189195    std::string name_suffix_str; 
    190     if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
    191      CTimer::get("XIOS").resume(); 
     196    if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
     197    CTimer::get("XIOS").resume(); 
    192198    filegroup_hdl->name_suffix.setValue(name_suffix_str); 
    193      CTimer::get("XIOS").suspend(); 
    194   } 
    195    
     199    CTimer::get("XIOS").suspend(); 
     200  } 
     201 
    196202  void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size) 
    197203  { 
    198      CTimer::get("XIOS").resume(); 
    199     if(!string_copy(filegroup_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size)) 
    200       ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
    201      CTimer::get("XIOS").suspend(); 
    202   } 
    203    
    204   bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl ) 
    205   { 
    206      CTimer::get("XIOS").resume(); 
    207     return filegroup_hdl->name_suffix.hasInheritedValue(); 
    208      CTimer::get("XIOS").suspend(); 
    209   } 
    210    
    211    
    212    
     204    CTimer::get("XIOS").resume(); 
     205    if (!string_copy(filegroup_hdl->name_suffix.getInheritedValue(), name_suffix, name_suffix_size)) 
     206      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", << "Input string is too short"); 
     207    CTimer::get("XIOS").suspend(); 
     208  } 
     209 
     210  bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl) 
     211  { 
     212     CTimer::get("XIOS").resume(); 
     213     bool isDefined = filegroup_hdl->name_suffix.hasInheritedValue(); 
     214     CTimer::get("XIOS").suspend(); 
     215     return isDefined; 
     216  } 
     217 
     218 
    213219  void cxios_set_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration output_freq_c) 
    214220  { 
    … …  
    225231    CTimer::get("XIOS").suspend(); 
    226232  } 
    227    
     233 
    228234  void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration* output_freq_c) 
    229235  { 
    … …  
    239245    CTimer::get("XIOS").suspend(); 
    240246  } 
    241    
    242   bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl ) 
    243   { 
    244      CTimer::get("XIOS").resume(); 
    245     return filegroup_hdl->output_freq.hasInheritedValue(); 
    246      CTimer::get("XIOS").suspend(); 
    247   } 
    248    
    249    
    250    
     247 
     248  bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl) 
     249  { 
     250     CTimer::get("XIOS").resume(); 
     251     bool isDefined = filegroup_hdl->output_freq.hasInheritedValue(); 
     252     CTimer::get("XIOS").suspend(); 
     253     return isDefined; 
     254  } 
     255 
     256 
    251257  void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level) 
    252258  { 
    253      CTimer::get("XIOS").resume(); 
     259    CTimer::get("XIOS").resume(); 
    254260    filegroup_hdl->output_level.setValue(output_level); 
    255      CTimer::get("XIOS").suspend(); 
    256   } 
    257    
     261    CTimer::get("XIOS").suspend(); 
     262  } 
     263 
    258264  void cxios_get_filegroup_output_level(filegroup_Ptr filegroup_hdl, int* output_level) 
    259265  { 
     266    CTimer::get("XIOS").resume(); 
    260267    *output_level = filegroup_hdl->output_level.getInheritedValue(); 
    261   } 
    262    
    263   bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl ) 
    264   { 
    265      CTimer::get("XIOS").resume(); 
    266     return filegroup_hdl->output_level.hasInheritedValue(); 
    267      CTimer::get("XIOS").suspend(); 
    268   } 
    269    
    270    
    271    
     268    CTimer::get("XIOS").suspend(); 
     269  } 
     270 
     271  bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl) 
     272  { 
     273     CTimer::get("XIOS").resume(); 
     274     bool isDefined = filegroup_hdl->output_level.hasInheritedValue(); 
     275     CTimer::get("XIOS").suspend(); 
     276     return isDefined; 
     277  } 
     278 
     279 
    272280  void cxios_set_filegroup_par_access(filegroup_Ptr filegroup_hdl, const char * par_access, int par_access_size) 
    273281  { 
    274282    std::string par_access_str; 
    275     if(!cstr2string(par_access, par_access_size, par_access_str)) return; 
    276      CTimer::get("XIOS").resume(); 
     283    if (!cstr2string(par_access, par_access_size, par_access_str)) return; 
     284    CTimer::get("XIOS").resume(); 
    277285    filegroup_hdl->par_access.fromString(par_access_str); 
    278      CTimer::get("XIOS").suspend(); 
    279   } 
    280    
     286    CTimer::get("XIOS").suspend(); 
     287  } 
     288 
    281289  void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size) 
    282290  { 
    283      CTimer::get("XIOS").resume(); 
    284     if(!string_copy(filegroup_hdl->par_access.getInheritedStringValue(),par_access , par_access_size)) 
    285       ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
    286      CTimer::get("XIOS").suspend(); 
    287   } 
    288    
    289   bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl ) 
    290   { 
    291      CTimer::get("XIOS").resume(); 
    292     return filegroup_hdl->par_access.hasInheritedValue(); 
    293      CTimer::get("XIOS").suspend(); 
    294   } 
    295    
    296    
    297    
     291    CTimer::get("XIOS").resume(); 
     292    if (!string_copy(filegroup_hdl->par_access.getInheritedStringValue(), par_access, par_access_size)) 
     293      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", << "Input string is too short"); 
     294    CTimer::get("XIOS").suspend(); 
     295  } 
     296 
     297  bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl) 
     298  { 
     299     CTimer::get("XIOS").resume(); 
     300     bool isDefined = filegroup_hdl->par_access.hasInheritedValue(); 
     301     CTimer::get("XIOS").suspend(); 
     302     return isDefined; 
     303  } 
     304 
     305 
    298306  void cxios_set_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration split_freq_c) 
    299307  { 
    … …  
    310318    CTimer::get("XIOS").suspend(); 
    311319  } 
    312    
     320 
    313321  void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration* split_freq_c) 
    314322  { 
    … …  
    324332    CTimer::get("XIOS").suspend(); 
    325333  } 
    326    
    327   bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl ) 
    328   { 
    329      CTimer::get("XIOS").resume(); 
    330     return filegroup_hdl->split_freq.hasInheritedValue(); 
    331      CTimer::get("XIOS").suspend(); 
    332   } 
    333    
    334    
    335    
     334 
     335  bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl) 
     336  { 
     337     CTimer::get("XIOS").resume(); 
     338     bool isDefined = filegroup_hdl->split_freq.hasInheritedValue(); 
     339     CTimer::get("XIOS").suspend(); 
     340     return isDefined; 
     341  } 
     342 
     343 
    336344  void cxios_set_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, const char * split_freq_format, int split_freq_format_size) 
    337345  { 
    338346    std::string split_freq_format_str; 
    339     if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
    340      CTimer::get("XIOS").resume(); 
     347    if (!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
     348    CTimer::get("XIOS").resume(); 
    341349    filegroup_hdl->split_freq_format.setValue(split_freq_format_str); 
    342      CTimer::get("XIOS").suspend(); 
    343   } 
    344    
     350    CTimer::get("XIOS").suspend(); 
     351  } 
     352 
    345353  void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size) 
    346354  { 
    347      CTimer::get("XIOS").resume(); 
    348     if(!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size)) 
    349       ERROR("void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short"); 
    350      CTimer::get("XIOS").suspend(); 
    351   } 
    352    
    353   bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl ) 
    354   { 
    355      CTimer::get("XIOS").resume(); 
    356     return filegroup_hdl->split_freq_format.hasInheritedValue(); 
    357      CTimer::get("XIOS").suspend(); 
    358   } 
    359    
    360    
    361    
     355    CTimer::get("XIOS").resume(); 
     356    if (!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(), split_freq_format, split_freq_format_size)) 
     357      ERROR("void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)", << "Input string is too short"); 
     358    CTimer::get("XIOS").suspend(); 
     359  } 
     360 
     361  bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl) 
     362  { 
     363     CTimer::get("XIOS").resume(); 
     364     bool isDefined = filegroup_hdl->split_freq_format.hasInheritedValue(); 
     365     CTimer::get("XIOS").suspend(); 
     366     return isDefined; 
     367  } 
     368 
     369 
    362370  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c) 
    363371  { 
    … …  
    374382    CTimer::get("XIOS").suspend(); 
    375383  } 
    376    
     384 
    377385  void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration* sync_freq_c) 
    378386  { 
    … …  
    388396    CTimer::get("XIOS").suspend(); 
    389397  } 
    390    
    391   bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl ) 
    392   { 
    393      CTimer::get("XIOS").resume(); 
    394     return filegroup_hdl->sync_freq.hasInheritedValue(); 
    395      CTimer::get("XIOS").suspend(); 
    396   } 
    397    
    398    
    399    
     398 
     399  bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl) 
     400  { 
     401     CTimer::get("XIOS").resume(); 
     402     bool isDefined = filegroup_hdl->sync_freq.hasInheritedValue(); 
     403     CTimer::get("XIOS").suspend(); 
     404     return isDefined; 
     405  } 
     406 
     407 
    400408  void cxios_set_filegroup_type(filegroup_Ptr filegroup_hdl, const char * type, int type_size) 
    401409  { 
    402410    std::string type_str; 
    403     if(!cstr2string(type, type_size, type_str)) return; 
    404      CTimer::get("XIOS").resume(); 
     411    if (!cstr2string(type, type_size, type_str)) return; 
     412    CTimer::get("XIOS").resume(); 
    405413    filegroup_hdl->type.fromString(type_str); 
    406      CTimer::get("XIOS").suspend(); 
    407   } 
    408    
     414    CTimer::get("XIOS").suspend(); 
     415  } 
     416 
    409417  void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size) 
    410418  { 
    411      CTimer::get("XIOS").resume(); 
    412     if(!string_copy(filegroup_hdl->type.getInheritedStringValue(),type , type_size)) 
    413       ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
    414      CTimer::get("XIOS").suspend(); 
    415   } 
    416    
    417   bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl ) 
    418   { 
    419      CTimer::get("XIOS").resume(); 
    420     return filegroup_hdl->type.hasInheritedValue(); 
    421      CTimer::get("XIOS").suspend(); 
    422   } 
    423    
    424    
    425    
    426    
     419    CTimer::get("XIOS").resume(); 
     420    if (!string_copy(filegroup_hdl->type.getInheritedStringValue(), type, type_size)) 
     421      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", << "Input string is too short"); 
     422    CTimer::get("XIOS").suspend(); 
     423  } 
     424 
     425  bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl) 
     426  { 
     427     CTimer::get("XIOS").resume(); 
     428     bool isDefined = filegroup_hdl->type.hasInheritedValue(); 
     429     CTimer::get("XIOS").suspend(); 
     430     return isDefined; 
     431  } 
    427432} 

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

    r575 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CGrid*  grid_Ptr; 
    19    
     18  typedef xios::CGrid* grid_Ptr; 
     19 
    2020  void cxios_set_grid_axis_domain_order(grid_Ptr grid_hdl, bool* axis_domain_order, int extent1) 
    2121  { 
    2222    CTimer::get("XIOS").resume(); 
    23     CArray<bool,1> tmp(axis_domain_order,shape(extent1),neverDeleteData) ; 
     23    CArray<bool,1> tmp(axis_domain_order, shape(extent1), neverDeleteData); 
    2424    grid_hdl->axis_domain_order.reference(tmp.copy()); 
    2525     CTimer::get("XIOS").suspend(); 
    2626  } 
    27    
     27 
    2828  void cxios_get_grid_axis_domain_order(grid_Ptr grid_hdl, bool* axis_domain_order, int extent1) 
    2929  { 
    3030    CTimer::get("XIOS").resume(); 
    31     CArray<bool,1> tmp(axis_domain_order,shape(extent1),neverDeleteData) ; 
    32     tmp=grid_hdl->axis_domain_order.getInheritedValue() ; 
     31    CArray<bool,1> tmp(axis_domain_order, shape(extent1), neverDeleteData); 
     32    tmp=grid_hdl->axis_domain_order.getInheritedValue(); 
    3333     CTimer::get("XIOS").suspend(); 
    3434  } 
    35    
    36   bool cxios_is_defined_grid_axis_domain_order(grid_Ptr grid_hdl ) 
     35 
     36  bool cxios_is_defined_grid_axis_domain_order(grid_Ptr grid_hdl) 
    3737  { 
    3838     CTimer::get("XIOS").resume(); 
    39     return grid_hdl->axis_domain_order.hasInheritedValue(); 
     39     bool isDefined = grid_hdl->axis_domain_order.hasInheritedValue(); 
    4040     CTimer::get("XIOS").suspend(); 
     41     return isDefined; 
    4142  } 
    42    
    43    
    44    
     43 
     44 
    4545  void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size) 
    4646  { 
    4747    std::string description_str; 
    48     if(!cstr2string(description, description_size, description_str)) return; 
    49      CTimer::get("XIOS").resume(); 
     48    if (!cstr2string(description, description_size, description_str)) return; 
     49    CTimer::get("XIOS").resume(); 
    5050    grid_hdl->description.setValue(description_str); 
    51      CTimer::get("XIOS").suspend(); 
     51    CTimer::get("XIOS").suspend(); 
    5252  } 
    53    
     53 
    5454  void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size) 
    5555  { 
    56      CTimer::get("XIOS").resume(); 
    57     if(!string_copy(grid_hdl->description.getInheritedValue(),description , description_size)) 
    58       ERROR("void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)", <<"Input string is to short"); 
    59      CTimer::get("XIOS").suspend(); 
     56    CTimer::get("XIOS").resume(); 
     57    if (!string_copy(grid_hdl->description.getInheritedValue(), description, description_size)) 
     58      ERROR("void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)", << "Input string is too short"); 
     59    CTimer::get("XIOS").suspend(); 
    6060  } 
    61    
    62   bool cxios_is_defined_grid_description(grid_Ptr grid_hdl ) 
     61 
     62  bool cxios_is_defined_grid_description(grid_Ptr grid_hdl) 
    6363  { 
    6464     CTimer::get("XIOS").resume(); 
    65     return grid_hdl->description.hasInheritedValue(); 
     65     bool isDefined = grid_hdl->description.hasInheritedValue(); 
    6666     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
    6768  } 
    68    
    69    
    70    
     69 
     70 
    7171  void cxios_set_grid_mask1(grid_Ptr grid_hdl, bool* mask1, int extent1) 
    7272  { 
    7373    CTimer::get("XIOS").resume(); 
    74     CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ; 
     74    CArray<bool,1> tmp(mask1, shape(extent1), neverDeleteData); 
    7575    grid_hdl->mask1.reference(tmp.copy()); 
    7676     CTimer::get("XIOS").suspend(); 
    7777  } 
    78    
     78 
    7979  void cxios_get_grid_mask1(grid_Ptr grid_hdl, bool* mask1, int extent1) 
    8080  { 
    8181    CTimer::get("XIOS").resume(); 
    82     CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ; 
    83     tmp=grid_hdl->mask1.getInheritedValue() ; 
     82    CArray<bool,1> tmp(mask1, shape(extent1), neverDeleteData); 
     83    tmp=grid_hdl->mask1.getInheritedValue(); 
    8484     CTimer::get("XIOS").suspend(); 
    8585  } 
    86    
    87   bool cxios_is_defined_grid_mask1(grid_Ptr grid_hdl ) 
     86 
     87  bool cxios_is_defined_grid_mask1(grid_Ptr grid_hdl) 
    8888  { 
    8989     CTimer::get("XIOS").resume(); 
    90     return grid_hdl->mask1.hasInheritedValue(); 
     90     bool isDefined = grid_hdl->mask1.hasInheritedValue(); 
    9191     CTimer::get("XIOS").suspend(); 
     92     return isDefined; 
    9293  } 
    93    
    94    
    95    
     94 
     95 
    9696  void cxios_set_grid_mask2(grid_Ptr grid_hdl, bool* mask2, int extent1, int extent2) 
    9797  { 
    9898    CTimer::get("XIOS").resume(); 
    99     CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ; 
     99    CArray<bool,2> tmp(mask2, shape(extent1, extent2), neverDeleteData); 
    100100    grid_hdl->mask2.reference(tmp.copy()); 
    101101     CTimer::get("XIOS").suspend(); 
    102102  } 
    103    
     103 
    104104  void cxios_get_grid_mask2(grid_Ptr grid_hdl, bool* mask2, int extent1, int extent2) 
    105105  { 
    106106    CTimer::get("XIOS").resume(); 
    107     CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ; 
    108     tmp=grid_hdl->mask2.getInheritedValue() ; 
     107    CArray<bool,2> tmp(mask2, shape(extent1, extent2), neverDeleteData); 
     108    tmp=grid_hdl->mask2.getInheritedValue(); 
    109109     CTimer::get("XIOS").suspend(); 
    110110  } 
    111    
    112   bool cxios_is_defined_grid_mask2(grid_Ptr grid_hdl ) 
     111 
     112  bool cxios_is_defined_grid_mask2(grid_Ptr grid_hdl) 
    113113  { 
    114114     CTimer::get("XIOS").resume(); 
    115     return grid_hdl->mask2.hasInheritedValue(); 
     115     bool isDefined = grid_hdl->mask2.hasInheritedValue(); 
    116116     CTimer::get("XIOS").suspend(); 
     117     return isDefined; 
    117118  } 
    118    
    119    
    120    
     119 
     120 
    121121  void cxios_set_grid_mask3(grid_Ptr grid_hdl, bool* mask3, int extent1, int extent2, int extent3) 
    122122  { 
    123123    CTimer::get("XIOS").resume(); 
    124     CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ; 
     124    CArray<bool,3> tmp(mask3, shape(extent1, extent2, extent3), neverDeleteData); 
    125125    grid_hdl->mask3.reference(tmp.copy()); 
    126126     CTimer::get("XIOS").suspend(); 
    127127  } 
    128    
     128 
    129129  void cxios_get_grid_mask3(grid_Ptr grid_hdl, bool* mask3, int extent1, int extent2, int extent3) 
    130130  { 
    131131    CTimer::get("XIOS").resume(); 
    132     CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ; 
    133     tmp=grid_hdl->mask3.getInheritedValue() ; 
     132    CArray<bool,3> tmp(mask3, shape(extent1, extent2, extent3), neverDeleteData); 
     133    tmp=grid_hdl->mask3.getInheritedValue(); 
    134134     CTimer::get("XIOS").suspend(); 
    135135  } 
    136    
    137   bool cxios_is_defined_grid_mask3(grid_Ptr grid_hdl ) 
     136 
     137  bool cxios_is_defined_grid_mask3(grid_Ptr grid_hdl) 
    138138  { 
    139139     CTimer::get("XIOS").resume(); 
    140     return grid_hdl->mask3.hasInheritedValue(); 
     140     bool isDefined = grid_hdl->mask3.hasInheritedValue(); 
    141141     CTimer::get("XIOS").suspend(); 
     142     return isDefined; 
    142143  } 
    143    
    144    
    145    
     144 
     145 
    146146  void cxios_set_grid_name(grid_Ptr grid_hdl, const char * name, int name_size) 
    147147  { 
    148148    std::string name_str; 
    149     if(!cstr2string(name, name_size, name_str)) return; 
    150      CTimer::get("XIOS").resume(); 
     149    if (!cstr2string(name, name_size, name_str)) return; 
     150    CTimer::get("XIOS").resume(); 
    151151    grid_hdl->name.setValue(name_str); 
    152      CTimer::get("XIOS").suspend(); 
     152    CTimer::get("XIOS").suspend(); 
    153153  } 
    154    
     154 
    155155  void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size) 
    156156  { 
    157      CTimer::get("XIOS").resume(); 
    158     if(!string_copy(grid_hdl->name.getInheritedValue(),name , name_size)) 
    159       ERROR("void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)", <<"Input string is to short"); 
    160      CTimer::get("XIOS").suspend(); 
     157    CTimer::get("XIOS").resume(); 
     158    if (!string_copy(grid_hdl->name.getInheritedValue(), name, name_size)) 
     159      ERROR("void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)", << "Input string is too short"); 
     160    CTimer::get("XIOS").suspend(); 
    161161  } 
    162    
    163   bool cxios_is_defined_grid_name(grid_Ptr grid_hdl ) 
     162 
     163  bool cxios_is_defined_grid_name(grid_Ptr grid_hdl) 
    164164  { 
    165165     CTimer::get("XIOS").resume(); 
    166     return grid_hdl->name.hasInheritedValue(); 
     166     bool isDefined = grid_hdl->name.hasInheritedValue(); 
    167167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
    168169  } 
    169    
    170    
    171    
    172    
    173170} 

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

    r575 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CGridGroup*  gridgroup_Ptr; 
    19    
     18  typedef xios::CGridGroup* gridgroup_Ptr; 
     19 
    2020  void cxios_set_gridgroup_axis_domain_order(gridgroup_Ptr gridgroup_hdl, bool* axis_domain_order, int extent1) 
    2121  { 
    2222    CTimer::get("XIOS").resume(); 
    23     CArray<bool,1> tmp(axis_domain_order,shape(extent1),neverDeleteData) ; 
     23    CArray<bool,1> tmp(axis_domain_order, shape(extent1), neverDeleteData); 
    2424    gridgroup_hdl->axis_domain_order.reference(tmp.copy()); 
    2525     CTimer::get("XIOS").suspend(); 
    2626  } 
    27    
     27 
    2828  void cxios_get_gridgroup_axis_domain_order(gridgroup_Ptr gridgroup_hdl, bool* axis_domain_order, int extent1) 
    2929  { 
    3030    CTimer::get("XIOS").resume(); 
    31     CArray<bool,1> tmp(axis_domain_order,shape(extent1),neverDeleteData) ; 
    32     tmp=gridgroup_hdl->axis_domain_order.getInheritedValue() ; 
     31    CArray<bool,1> tmp(axis_domain_order, shape(extent1), neverDeleteData); 
     32    tmp=gridgroup_hdl->axis_domain_order.getInheritedValue(); 
    3333     CTimer::get("XIOS").suspend(); 
    3434  } 
    35    
    36   bool cxios_is_defined_gridgroup_axis_domain_order(gridgroup_Ptr gridgroup_hdl ) 
     35 
     36  bool cxios_is_defined_gridgroup_axis_domain_order(gridgroup_Ptr gridgroup_hdl) 
    3737  { 
    3838     CTimer::get("XIOS").resume(); 
    39     return gridgroup_hdl->axis_domain_order.hasInheritedValue(); 
     39     bool isDefined = gridgroup_hdl->axis_domain_order.hasInheritedValue(); 
    4040     CTimer::get("XIOS").suspend(); 
     41     return isDefined; 
    4142  } 
    42    
    43    
    44    
     43 
     44 
    4545  void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size) 
    4646  { 
    4747    std::string description_str; 
    48     if(!cstr2string(description, description_size, description_str)) return; 
    49      CTimer::get("XIOS").resume(); 
     48    if (!cstr2string(description, description_size, description_str)) return; 
     49    CTimer::get("XIOS").resume(); 
    5050    gridgroup_hdl->description.setValue(description_str); 
    51      CTimer::get("XIOS").suspend(); 
     51    CTimer::get("XIOS").suspend(); 
    5252  } 
    53    
     53 
    5454  void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size) 
    5555  { 
    56      CTimer::get("XIOS").resume(); 
    57     if(!string_copy(gridgroup_hdl->description.getInheritedValue(),description , description_size)) 
    58       ERROR("void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
    59      CTimer::get("XIOS").suspend(); 
     56    CTimer::get("XIOS").resume(); 
     57    if (!string_copy(gridgroup_hdl->description.getInheritedValue(), description, description_size)) 
     58      ERROR("void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)", << "Input string is too short"); 
     59    CTimer::get("XIOS").suspend(); 
    6060  } 
    61    
    62   bool cxios_is_defined_gridgroup_description(gridgroup_Ptr gridgroup_hdl ) 
     61 
     62  bool cxios_is_defined_gridgroup_description(gridgroup_Ptr gridgroup_hdl) 
    6363  { 
    6464     CTimer::get("XIOS").resume(); 
    65     return gridgroup_hdl->description.hasInheritedValue(); 
     65     bool isDefined = gridgroup_hdl->description.hasInheritedValue(); 
    6666     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
    6768  } 
    68    
    69    
    70    
     69 
     70 
    7171  void cxios_set_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, const char * group_ref, int group_ref_size) 
    7272  { 
    7373    std::string group_ref_str; 
    74     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    75      CTimer::get("XIOS").resume(); 
     74    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     75    CTimer::get("XIOS").resume(); 
    7676    gridgroup_hdl->group_ref.setValue(group_ref_str); 
    77      CTimer::get("XIOS").suspend(); 
     77    CTimer::get("XIOS").suspend(); 
    7878  } 
    79    
     79 
    8080  void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size) 
    8181  { 
    82      CTimer::get("XIOS").resume(); 
    83     if(!string_copy(gridgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    84       ERROR("void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    85      CTimer::get("XIOS").suspend(); 
     82    CTimer::get("XIOS").resume(); 
     83    if (!string_copy(gridgroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     84      ERROR("void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     85    CTimer::get("XIOS").suspend(); 
    8686  } 
    87    
    88   bool cxios_is_defined_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl ) 
     87 
     88  bool cxios_is_defined_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl) 
    8989  { 
    9090     CTimer::get("XIOS").resume(); 
    91     return gridgroup_hdl->group_ref.hasInheritedValue(); 
     91     bool isDefined = gridgroup_hdl->group_ref.hasInheritedValue(); 
    9292     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
    9394  } 
    94    
    95    
    96    
     95 
     96 
    9797  void cxios_set_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl, bool* mask1, int extent1) 
    9898  { 
    9999    CTimer::get("XIOS").resume(); 
    100     CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ; 
     100    CArray<bool,1> tmp(mask1, shape(extent1), neverDeleteData); 
    101101    gridgroup_hdl->mask1.reference(tmp.copy()); 
    102102     CTimer::get("XIOS").suspend(); 
    103103  } 
    104    
     104 
    105105  void cxios_get_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl, bool* mask1, int extent1) 
    106106  { 
    107107    CTimer::get("XIOS").resume(); 
    108     CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ; 
    109     tmp=gridgroup_hdl->mask1.getInheritedValue() ; 
     108    CArray<bool,1> tmp(mask1, shape(extent1), neverDeleteData); 
     109    tmp=gridgroup_hdl->mask1.getInheritedValue(); 
    110110     CTimer::get("XIOS").suspend(); 
    111111  } 
    112    
    113   bool cxios_is_defined_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl ) 
     112 
     113  bool cxios_is_defined_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl) 
    114114  { 
    115115     CTimer::get("XIOS").resume(); 
    116     return gridgroup_hdl->mask1.hasInheritedValue(); 
     116     bool isDefined = gridgroup_hdl->mask1.hasInheritedValue(); 
    117117     CTimer::get("XIOS").suspend(); 
     118     return isDefined; 
    118119  } 
    119    
    120    
    121    
     120 
     121 
    122122  void cxios_set_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl, bool* mask2, int extent1, int extent2) 
    123123  { 
    124124    CTimer::get("XIOS").resume(); 
    125     CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ; 
     125    CArray<bool,2> tmp(mask2, shape(extent1, extent2), neverDeleteData); 
    126126    gridgroup_hdl->mask2.reference(tmp.copy()); 
    127127     CTimer::get("XIOS").suspend(); 
    128128  } 
    129    
     129 
    130130  void cxios_get_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl, bool* mask2, int extent1, int extent2) 
    131131  { 
    132132    CTimer::get("XIOS").resume(); 
    133     CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ; 
    134     tmp=gridgroup_hdl->mask2.getInheritedValue() ; 
     133    CArray<bool,2> tmp(mask2, shape(extent1, extent2), neverDeleteData); 
     134    tmp=gridgroup_hdl->mask2.getInheritedValue(); 
    135135     CTimer::get("XIOS").suspend(); 
    136136  } 
    137    
    138   bool cxios_is_defined_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl ) 
     137 
     138  bool cxios_is_defined_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl) 
    139139  { 
    140140     CTimer::get("XIOS").resume(); 
    141     return gridgroup_hdl->mask2.hasInheritedValue(); 
     141     bool isDefined = gridgroup_hdl->mask2.hasInheritedValue(); 
    142142     CTimer::get("XIOS").suspend(); 
     143     return isDefined; 
    143144  } 
    144    
    145    
    146    
     145 
     146 
    147147  void cxios_set_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl, bool* mask3, int extent1, int extent2, int extent3) 
    148148  { 
    149149    CTimer::get("XIOS").resume(); 
    150     CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ; 
     150    CArray<bool,3> tmp(mask3, shape(extent1, extent2, extent3), neverDeleteData); 
    151151    gridgroup_hdl->mask3.reference(tmp.copy()); 
    152152     CTimer::get("XIOS").suspend(); 
    153153  } 
    154    
     154 
    155155  void cxios_get_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl, bool* mask3, int extent1, int extent2, int extent3) 
    156156  { 
    157157    CTimer::get("XIOS").resume(); 
    158     CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ; 
    159     tmp=gridgroup_hdl->mask3.getInheritedValue() ; 
     158    CArray<bool,3> tmp(mask3, shape(extent1, extent2, extent3), neverDeleteData); 
     159    tmp=gridgroup_hdl->mask3.getInheritedValue(); 
    160160     CTimer::get("XIOS").suspend(); 
    161161  } 
    162    
    163   bool cxios_is_defined_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl ) 
     162 
     163  bool cxios_is_defined_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl) 
    164164  { 
    165165     CTimer::get("XIOS").resume(); 
    166     return gridgroup_hdl->mask3.hasInheritedValue(); 
     166     bool isDefined = gridgroup_hdl->mask3.hasInheritedValue(); 
    167167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
    168169  } 
    169    
    170    
    171    
     170 
     171 
    172172  void cxios_set_gridgroup_name(gridgroup_Ptr gridgroup_hdl, const char * name, int name_size) 
    173173  { 
    174174    std::string name_str; 
    175     if(!cstr2string(name, name_size, name_str)) return; 
    176      CTimer::get("XIOS").resume(); 
     175    if (!cstr2string(name, name_size, name_str)) return; 
     176    CTimer::get("XIOS").resume(); 
    177177    gridgroup_hdl->name.setValue(name_str); 
    178      CTimer::get("XIOS").suspend(); 
     178    CTimer::get("XIOS").suspend(); 
    179179  } 
    180    
     180 
    181181  void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size) 
    182182  { 
    183      CTimer::get("XIOS").resume(); 
    184     if(!string_copy(gridgroup_hdl->name.getInheritedValue(),name , name_size)) 
    185       ERROR("void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    186      CTimer::get("XIOS").suspend(); 
     183    CTimer::get("XIOS").resume(); 
     184    if (!string_copy(gridgroup_hdl->name.getInheritedValue(), name, name_size)) 
     185      ERROR("void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     186    CTimer::get("XIOS").suspend(); 
    187187  } 
    188    
    189   bool cxios_is_defined_gridgroup_name(gridgroup_Ptr gridgroup_hdl ) 
     188 
     189  bool cxios_is_defined_gridgroup_name(gridgroup_Ptr gridgroup_hdl) 
    190190  { 
    191191     CTimer::get("XIOS").resume(); 
    192     return gridgroup_hdl->name.hasInheritedValue(); 
     192     bool isDefined = gridgroup_hdl->name.hasInheritedValue(); 
    193193     CTimer::get("XIOS").suspend(); 
     194     return isDefined; 
    194195  } 
    195    
    196    
    197    
    198    
    199196} 

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

    r532 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CVariable*  variable_Ptr; 
    19    
     18  typedef xios::CVariable* variable_Ptr; 
     19 
    2020  void cxios_set_variable_name(variable_Ptr variable_hdl, const char * name, int name_size) 
    2121  { 
    2222    std::string name_str; 
    23     if(!cstr2string(name, name_size, name_str)) return; 
    24      CTimer::get("XIOS").resume(); 
     23    if (!cstr2string(name, name_size, name_str)) return; 
     24    CTimer::get("XIOS").resume(); 
    2525    variable_hdl->name.setValue(name_str); 
    26      CTimer::get("XIOS").suspend(); 
     26    CTimer::get("XIOS").suspend(); 
    2727  } 
    28    
     28 
    2929  void cxios_get_variable_name(variable_Ptr variable_hdl, char * name, int name_size) 
    3030  { 
    31      CTimer::get("XIOS").resume(); 
    32     if(!string_copy(variable_hdl->name.getInheritedValue(),name , name_size)) 
    33       ERROR("void cxios_get_variable_name(variable_Ptr variable_hdl, char * name, int name_size)", <<"Input string is to short"); 
    34      CTimer::get("XIOS").suspend(); 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(variable_hdl->name.getInheritedValue(), name, name_size)) 
     33      ERROR("void cxios_get_variable_name(variable_Ptr variable_hdl, char * name, int name_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
    3535  } 
    36    
    37   bool cxios_is_defined_variable_name(variable_Ptr variable_hdl ) 
     36 
     37  bool cxios_is_defined_variable_name(variable_Ptr variable_hdl) 
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return variable_hdl->name.hasInheritedValue(); 
     40     bool isDefined = variable_hdl->name.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
    4243  } 
    43    
    44    
    45    
     44 
     45 
    4646  void cxios_set_variable_type(variable_Ptr variable_hdl, const char * type, int type_size) 
    4747  { 
    4848    std::string type_str; 
    49     if(!cstr2string(type, type_size, type_str)) return; 
    50      CTimer::get("XIOS").resume(); 
     49    if (!cstr2string(type, type_size, type_str)) return; 
     50    CTimer::get("XIOS").resume(); 
    5151    variable_hdl->type.fromString(type_str); 
    52      CTimer::get("XIOS").suspend(); 
     52    CTimer::get("XIOS").suspend(); 
    5353  } 
    54    
     54 
    5555  void cxios_get_variable_type(variable_Ptr variable_hdl, char * type, int type_size) 
    5656  { 
    57      CTimer::get("XIOS").resume(); 
    58     if(!string_copy(variable_hdl->type.getInheritedStringValue(),type , type_size)) 
    59       ERROR("void cxios_get_variable_type(variable_Ptr variable_hdl, char * type, int type_size)", <<"Input string is to short"); 
    60      CTimer::get("XIOS").suspend(); 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(variable_hdl->type.getInheritedStringValue(), type, type_size)) 
     59      ERROR("void cxios_get_variable_type(variable_Ptr variable_hdl, char * type, int type_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
    6161  } 
    62    
    63   bool cxios_is_defined_variable_type(variable_Ptr variable_hdl ) 
     62 
     63  bool cxios_is_defined_variable_type(variable_Ptr variable_hdl) 
    6464  { 
    6565     CTimer::get("XIOS").resume(); 
    66     return variable_hdl->type.hasInheritedValue(); 
     66     bool isDefined = variable_hdl->type.hasInheritedValue(); 
    6767     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
    6869  } 
    69    
    70    
    71    
    72    
    7370} 

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

    r532 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CVariableGroup*  variablegroup_Ptr; 
    19    
     18  typedef xios::CVariableGroup* variablegroup_Ptr; 
     19 
    2020  void cxios_set_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl, const char * group_ref, int group_ref_size) 
    2121  { 
    2222    std::string group_ref_str; 
    23     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
    24      CTimer::get("XIOS").resume(); 
     23    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     24    CTimer::get("XIOS").resume(); 
    2525    variablegroup_hdl->group_ref.setValue(group_ref_str); 
    26      CTimer::get("XIOS").suspend(); 
     26    CTimer::get("XIOS").suspend(); 
    2727  } 
    28    
     28 
    2929  void cxios_get_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl, char * group_ref, int group_ref_size) 
    3030  { 
    31      CTimer::get("XIOS").resume(); 
    32     if(!string_copy(variablegroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    33       ERROR("void cxios_get_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    34      CTimer::get("XIOS").suspend(); 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(variablegroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size)) 
     33      ERROR("void cxios_get_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
    3535  } 
    36    
    37   bool cxios_is_defined_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl ) 
     36 
     37  bool cxios_is_defined_variablegroup_group_ref(variablegroup_Ptr variablegroup_hdl) 
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return variablegroup_hdl->group_ref.hasInheritedValue(); 
     40     bool isDefined = variablegroup_hdl->group_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
    4243  } 
    43    
    44    
    45    
     44 
     45 
    4646  void cxios_set_variablegroup_name(variablegroup_Ptr variablegroup_hdl, const char * name, int name_size) 
    4747  { 
    4848    std::string name_str; 
    49     if(!cstr2string(name, name_size, name_str)) return; 
    50      CTimer::get("XIOS").resume(); 
     49    if (!cstr2string(name, name_size, name_str)) return; 
     50    CTimer::get("XIOS").resume(); 
    5151    variablegroup_hdl->name.setValue(name_str); 
    52      CTimer::get("XIOS").suspend(); 
     52    CTimer::get("XIOS").suspend(); 
    5353  } 
    54    
     54 
    5555  void cxios_get_variablegroup_name(variablegroup_Ptr variablegroup_hdl, char * name, int name_size) 
    5656  { 
    57      CTimer::get("XIOS").resume(); 
    58     if(!string_copy(variablegroup_hdl->name.getInheritedValue(),name , name_size)) 
    59       ERROR("void cxios_get_variablegroup_name(variablegroup_Ptr variablegroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    60      CTimer::get("XIOS").suspend(); 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(variablegroup_hdl->name.getInheritedValue(), name, name_size)) 
     59      ERROR("void cxios_get_variablegroup_name(variablegroup_Ptr variablegroup_hdl, char * name, int name_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
    6161  } 
    62    
    63   bool cxios_is_defined_variablegroup_name(variablegroup_Ptr variablegroup_hdl ) 
     62 
     63  bool cxios_is_defined_variablegroup_name(variablegroup_Ptr variablegroup_hdl) 
    6464  { 
    6565     CTimer::get("XIOS").resume(); 
    66     return variablegroup_hdl->name.hasInheritedValue(); 
     66     bool isDefined = variablegroup_hdl->name.hasInheritedValue(); 
    6767     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
    6869  } 
    69    
    70    
    71    
     70 
     71 
    7272  void cxios_set_variablegroup_type(variablegroup_Ptr variablegroup_hdl, const char * type, int type_size) 
    7373  { 
    7474    std::string type_str; 
    75     if(!cstr2string(type, type_size, type_str)) return; 
    76      CTimer::get("XIOS").resume(); 
     75    if (!cstr2string(type, type_size, type_str)) return; 
     76    CTimer::get("XIOS").resume(); 
    7777    variablegroup_hdl->type.fromString(type_str); 
    78      CTimer::get("XIOS").suspend(); 
     78    CTimer::get("XIOS").suspend(); 
    7979  } 
    80    
     80 
    8181  void cxios_get_variablegroup_type(variablegroup_Ptr variablegroup_hdl, char * type, int type_size) 
    8282  { 
    83      CTimer::get("XIOS").resume(); 
    84     if(!string_copy(variablegroup_hdl->type.getInheritedStringValue(),type , type_size)) 
    85       ERROR("void cxios_get_variablegroup_type(variablegroup_Ptr variablegroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
    86      CTimer::get("XIOS").suspend(); 
     83    CTimer::get("XIOS").resume(); 
     84    if (!string_copy(variablegroup_hdl->type.getInheritedStringValue(), type, type_size)) 
     85      ERROR("void cxios_get_variablegroup_type(variablegroup_Ptr variablegroup_hdl, char * type, int type_size)", << "Input string is too short"); 
     86    CTimer::get("XIOS").suspend(); 
    8787  } 
    88    
    89   bool cxios_is_defined_variablegroup_type(variablegroup_Ptr variablegroup_hdl ) 
     88 
     89  bool cxios_is_defined_variablegroup_type(variablegroup_Ptr variablegroup_hdl) 
    9090  { 
    9191     CTimer::get("XIOS").resume(); 
    92     return variablegroup_hdl->type.hasInheritedValue(); 
     92     bool isDefined = variablegroup_hdl->type.hasInheritedValue(); 
    9393     CTimer::get("XIOS").suspend(); 
     94     return isDefined; 
    9495  } 
    95    
    96    
    97    
    98    
    9996} 
Note: See TracChangeset for help on using the changeset viewer.