source: XIOS/branchs/xios-1.0/src/interface/c_attr/icfilegroup_attr.cpp @ 581

Last change on this file since 581 was 581, checked in by rlacroix, 6 years ago

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

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:eol-style set to native
File size: 13.4 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                   *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include "xmlioserver.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.hpp"
12#include "timer.hpp"
13#include "node_type.hpp"
14
15extern "C"
16{
17  typedef xios::CFileGroup*  filegroup_Ptr;
18 
19  void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size)
20  {
21    std::string description_str;
22    if(!cstr2string(description, description_size, description_str)) return;
23     CTimer::get("XIOS").resume();
24    filegroup_hdl->description.setValue(description_str);
25    filegroup_hdl->sendAttributToServer(filegroup_hdl->description);
26     CTimer::get("XIOS").suspend();
27  }
28 
29  void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)
30  {
31     CTimer::get("XIOS").resume();
32    if(!string_copy(filegroup_hdl->description.getInheritedValue(),description , description_size))
33      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", <<"Input string is to short");
34     CTimer::get("XIOS").suspend();
35  }
36 
37  bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl )
38  {
39    CTimer::get("XIOS").resume();
40    bool isDefined = filegroup_hdl->description.hasInheritedValue();
41    CTimer::get("XIOS").suspend();
42    return isDefined;
43  }
44 
45 
46 
47  void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled)
48  {
49     CTimer::get("XIOS").resume();
50    filegroup_hdl->enabled.setValue(enabled);
51    filegroup_hdl->sendAttributToServer(filegroup_hdl->enabled);
52     CTimer::get("XIOS").suspend();
53  }
54 
55  void cxios_get_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool* enabled)
56  {
57    *enabled = filegroup_hdl->enabled.getInheritedValue();
58  }
59 
60  bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl )
61  {
62    CTimer::get("XIOS").resume();
63    bool isDefined = filegroup_hdl->enabled.hasInheritedValue();
64    CTimer::get("XIOS").suspend();
65    return isDefined;
66  }
67 
68 
69 
70  void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size)
71  {
72    std::string group_ref_str;
73    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
74     CTimer::get("XIOS").resume();
75    filegroup_hdl->group_ref.setValue(group_ref_str);
76    filegroup_hdl->sendAttributToServer(filegroup_hdl->group_ref);
77     CTimer::get("XIOS").suspend();
78  }
79 
80  void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)
81  {
82     CTimer::get("XIOS").resume();
83    if(!string_copy(filegroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size))
84      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
85     CTimer::get("XIOS").suspend();
86  }
87 
88  bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl )
89  {
90    CTimer::get("XIOS").resume();
91    bool isDefined = filegroup_hdl->group_ref.hasInheritedValue();
92    CTimer::get("XIOS").suspend();
93    return isDefined;
94  }
95 
96 
97 
98  void cxios_set_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int min_digits)
99  {
100     CTimer::get("XIOS").resume();
101    filegroup_hdl->min_digits.setValue(min_digits);
102    filegroup_hdl->sendAttributToServer(filegroup_hdl->min_digits);
103     CTimer::get("XIOS").suspend();
104  }
105 
106  void cxios_get_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int* min_digits)
107  {
108    *min_digits = filegroup_hdl->min_digits.getInheritedValue();
109  }
110 
111  bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl )
112  {
113    CTimer::get("XIOS").resume();
114    bool isDefined = filegroup_hdl->min_digits.hasInheritedValue();
115    CTimer::get("XIOS").suspend();
116    return isDefined;
117  }
118 
119 
120 
121  void cxios_set_filegroup_name(filegroup_Ptr filegroup_hdl, const char * name, int name_size)
122  {
123    std::string name_str;
124    if(!cstr2string(name, name_size, name_str)) return;
125     CTimer::get("XIOS").resume();
126    filegroup_hdl->name.setValue(name_str);
127    filegroup_hdl->sendAttributToServer(filegroup_hdl->name);
128     CTimer::get("XIOS").suspend();
129  }
130 
131  void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)
132  {
133     CTimer::get("XIOS").resume();
134    if(!string_copy(filegroup_hdl->name.getInheritedValue(),name , name_size))
135      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", <<"Input string is to short");
136     CTimer::get("XIOS").suspend();
137  }
138 
139  bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl )
140  {
141    CTimer::get("XIOS").resume();
142    bool isDefined = filegroup_hdl->name.hasInheritedValue();
143    CTimer::get("XIOS").suspend();
144    return isDefined;
145  }
146 
147 
148 
149  void cxios_set_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, const char * name_suffix, int name_suffix_size)
150  {
151    std::string name_suffix_str;
152    if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return;
153     CTimer::get("XIOS").resume();
154    filegroup_hdl->name_suffix.setValue(name_suffix_str);
155    filegroup_hdl->sendAttributToServer(filegroup_hdl->name_suffix);
156     CTimer::get("XIOS").suspend();
157  }
158 
159  void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)
160  {
161     CTimer::get("XIOS").resume();
162    if(!string_copy(filegroup_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size))
163      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short");
164     CTimer::get("XIOS").suspend();
165  }
166 
167  bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl )
168  {
169    CTimer::get("XIOS").resume();
170    bool isDefined = filegroup_hdl->name_suffix.hasInheritedValue();
171    CTimer::get("XIOS").suspend();
172    return isDefined;
173  }
174 
175 
176 
177  void cxios_set_filegroup_output_freq(filegroup_Ptr filegroup_hdl, const char * output_freq, int output_freq_size)
178  {
179    std::string output_freq_str;
180    if(!cstr2string(output_freq, output_freq_size, output_freq_str)) return;
181     CTimer::get("XIOS").resume();
182    filegroup_hdl->output_freq.setValue(output_freq_str);
183    filegroup_hdl->sendAttributToServer(filegroup_hdl->output_freq);
184     CTimer::get("XIOS").suspend();
185  }
186 
187  void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)
188  {
189     CTimer::get("XIOS").resume();
190    if(!string_copy(filegroup_hdl->output_freq.getInheritedValue(),output_freq , output_freq_size))
191      ERROR("void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short");
192     CTimer::get("XIOS").suspend();
193  }
194 
195  bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl )
196  {
197    CTimer::get("XIOS").resume();
198    bool isDefined = filegroup_hdl->output_freq.hasInheritedValue();
199    CTimer::get("XIOS").suspend();
200    return isDefined;
201  }
202 
203 
204 
205  void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level)
206  {
207     CTimer::get("XIOS").resume();
208    filegroup_hdl->output_level.setValue(output_level);
209    filegroup_hdl->sendAttributToServer(filegroup_hdl->output_level);
210     CTimer::get("XIOS").suspend();
211  }
212 
213  void cxios_get_filegroup_output_level(filegroup_Ptr filegroup_hdl, int* output_level)
214  {
215    *output_level = filegroup_hdl->output_level.getInheritedValue();
216  }
217 
218  bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl )
219  {
220    CTimer::get("XIOS").resume();
221    bool isDefined = filegroup_hdl->output_level.hasInheritedValue();
222    CTimer::get("XIOS").suspend();
223    return isDefined;
224  }
225 
226 
227 
228  void cxios_set_filegroup_par_access(filegroup_Ptr filegroup_hdl, const char * par_access, int par_access_size)
229  {
230    std::string par_access_str;
231    if(!cstr2string(par_access, par_access_size, par_access_str)) return;
232     CTimer::get("XIOS").resume();
233    filegroup_hdl->par_access.setValue(par_access_str);
234    filegroup_hdl->sendAttributToServer(filegroup_hdl->par_access);
235     CTimer::get("XIOS").suspend();
236  }
237 
238  void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)
239  {
240     CTimer::get("XIOS").resume();
241    if(!string_copy(filegroup_hdl->par_access.getInheritedValue(),par_access , par_access_size))
242      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", <<"Input string is to short");
243     CTimer::get("XIOS").suspend();
244  }
245 
246  bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl )
247  {
248    CTimer::get("XIOS").resume();
249    bool isDefined = filegroup_hdl->par_access.hasInheritedValue();
250    CTimer::get("XIOS").suspend();
251    return isDefined;
252  }
253 
254 
255 
256  void cxios_set_filegroup_split_freq(filegroup_Ptr filegroup_hdl, const char * split_freq, int split_freq_size)
257  {
258    std::string split_freq_str;
259    if(!cstr2string(split_freq, split_freq_size, split_freq_str)) return;
260     CTimer::get("XIOS").resume();
261    filegroup_hdl->split_freq.setValue(split_freq_str);
262    filegroup_hdl->sendAttributToServer(filegroup_hdl->split_freq);
263     CTimer::get("XIOS").suspend();
264  }
265 
266  void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)
267  {
268     CTimer::get("XIOS").resume();
269    if(!string_copy(filegroup_hdl->split_freq.getInheritedValue(),split_freq , split_freq_size))
270      ERROR("void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short");
271     CTimer::get("XIOS").suspend();
272  }
273 
274  bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl )
275  {
276    CTimer::get("XIOS").resume();
277    bool isDefined = filegroup_hdl->split_freq.hasInheritedValue();
278    CTimer::get("XIOS").suspend();
279    return isDefined;
280  }
281 
282 
283 
284  void cxios_set_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, const char * split_freq_format, int split_freq_format_size)
285  {
286    std::string split_freq_format_str;
287    if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return;
288     CTimer::get("XIOS").resume();
289    filegroup_hdl->split_freq_format.setValue(split_freq_format_str);
290    filegroup_hdl->sendAttributToServer(filegroup_hdl->split_freq_format);
291     CTimer::get("XIOS").suspend();
292  }
293 
294  void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)
295  {
296     CTimer::get("XIOS").resume();
297    if(!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size))
298      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");
299     CTimer::get("XIOS").suspend();
300  }
301 
302  bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl )
303  {
304    CTimer::get("XIOS").resume();
305    bool isDefined = filegroup_hdl->split_freq_format.hasInheritedValue();
306    CTimer::get("XIOS").suspend();
307    return isDefined;
308  }
309 
310 
311 
312  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, const char * sync_freq, int sync_freq_size)
313  {
314    std::string sync_freq_str;
315    if(!cstr2string(sync_freq, sync_freq_size, sync_freq_str)) return;
316     CTimer::get("XIOS").resume();
317    filegroup_hdl->sync_freq.setValue(sync_freq_str);
318    filegroup_hdl->sendAttributToServer(filegroup_hdl->sync_freq);
319     CTimer::get("XIOS").suspend();
320  }
321 
322  void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)
323  {
324     CTimer::get("XIOS").resume();
325    if(!string_copy(filegroup_hdl->sync_freq.getInheritedValue(),sync_freq , sync_freq_size))
326      ERROR("void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short");
327     CTimer::get("XIOS").suspend();
328  }
329 
330  bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl )
331  {
332    CTimer::get("XIOS").resume();
333    bool isDefined = filegroup_hdl->sync_freq.hasInheritedValue();
334    CTimer::get("XIOS").suspend();
335    return isDefined;
336  }
337 
338 
339 
340  void cxios_set_filegroup_type(filegroup_Ptr filegroup_hdl, const char * type, int type_size)
341  {
342    std::string type_str;
343    if(!cstr2string(type, type_size, type_str)) return;
344     CTimer::get("XIOS").resume();
345    filegroup_hdl->type.fromString(type_str);
346    filegroup_hdl->sendAttributToServer(filegroup_hdl->type);
347     CTimer::get("XIOS").suspend();
348  }
349 
350  void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)
351  {
352     CTimer::get("XIOS").resume();
353    if(!string_copy(filegroup_hdl->type.getInheritedStringValue(),type , type_size))
354      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short");
355     CTimer::get("XIOS").suspend();
356  }
357 
358  bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl )
359  {
360    CTimer::get("XIOS").resume();
361    bool isDefined = filegroup_hdl->type.hasInheritedValue();
362    CTimer::get("XIOS").suspend();
363    return isDefined;
364  }
365 
366 
367 
368 
369}
Note: See TracBrowser for help on using the repository browser.