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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/interface/c_attr/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} 
Note: See TracChangeset for help on using the changeset viewer.