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/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} 
Note: See TracChangeset for help on using the changeset viewer.