source: XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp @ 1170

Last change on this file since 1170 was 1170, checked in by mhnguyen, 7 years ago

Update Fortran interface.

  • 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: 29.8 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 "xios.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.hpp"
12#include "icdate.hpp"
13#include "timer.hpp"
14#include "node_type.hpp"
15
16extern "C"
17{
18  typedef xios::CFileGroup* filegroup_Ptr;
19
20  void cxios_set_filegroup_append(filegroup_Ptr filegroup_hdl, bool append)
21  {
22    CTimer::get("XIOS").resume();
23    filegroup_hdl->append.setValue(append);
24    CTimer::get("XIOS").suspend();
25  }
26
27  void cxios_get_filegroup_append(filegroup_Ptr filegroup_hdl, bool* append)
28  {
29    CTimer::get("XIOS").resume();
30    *append = filegroup_hdl->append.getInheritedValue();
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
43  void cxios_set_filegroup_compression_level(filegroup_Ptr filegroup_hdl, int compression_level)
44  {
45    CTimer::get("XIOS").resume();
46    filegroup_hdl->compression_level.setValue(compression_level);
47    CTimer::get("XIOS").suspend();
48  }
49
50  void cxios_get_filegroup_compression_level(filegroup_Ptr filegroup_hdl, int* compression_level)
51  {
52    CTimer::get("XIOS").resume();
53    *compression_level = filegroup_hdl->compression_level.getInheritedValue();
54    CTimer::get("XIOS").suspend();
55  }
56
57  bool cxios_is_defined_filegroup_compression_level(filegroup_Ptr filegroup_hdl)
58  {
59     CTimer::get("XIOS").resume();
60     bool isDefined = filegroup_hdl->compression_level.hasInheritedValue();
61     CTimer::get("XIOS").suspend();
62     return isDefined;
63  }
64
65
66  void cxios_set_filegroup_convention(filegroup_Ptr filegroup_hdl, const char * convention, int convention_size)
67  {
68    std::string convention_str;
69    if (!cstr2string(convention, convention_size, convention_str)) return;
70    CTimer::get("XIOS").resume();
71    filegroup_hdl->convention.fromString(convention_str);
72    CTimer::get("XIOS").suspend();
73  }
74
75  void cxios_get_filegroup_convention(filegroup_Ptr filegroup_hdl, char * convention, int convention_size)
76  {
77    CTimer::get("XIOS").resume();
78    if (!string_copy(filegroup_hdl->convention.getInheritedStringValue(), convention, convention_size))
79      ERROR("void cxios_get_filegroup_convention(filegroup_Ptr filegroup_hdl, char * convention, int convention_size)", << "Input string is too short");
80    CTimer::get("XIOS").suspend();
81  }
82
83  bool cxios_is_defined_filegroup_convention(filegroup_Ptr filegroup_hdl)
84  {
85     CTimer::get("XIOS").resume();
86     bool isDefined = filegroup_hdl->convention.hasInheritedValue();
87     CTimer::get("XIOS").suspend();
88     return isDefined;
89  }
90
91
92  void cxios_set_filegroup_convention_str(filegroup_Ptr filegroup_hdl, const char * convention_str, int convention_str_size)
93  {
94    std::string convention_str_str;
95    if (!cstr2string(convention_str, convention_str_size, convention_str_str)) return;
96    CTimer::get("XIOS").resume();
97    filegroup_hdl->convention_str.setValue(convention_str_str);
98    CTimer::get("XIOS").suspend();
99  }
100
101  void cxios_get_filegroup_convention_str(filegroup_Ptr filegroup_hdl, char * convention_str, int convention_str_size)
102  {
103    CTimer::get("XIOS").resume();
104    if (!string_copy(filegroup_hdl->convention_str.getInheritedValue(), convention_str, convention_str_size))
105      ERROR("void cxios_get_filegroup_convention_str(filegroup_Ptr filegroup_hdl, char * convention_str, int convention_str_size)", << "Input string is too short");
106    CTimer::get("XIOS").suspend();
107  }
108
109  bool cxios_is_defined_filegroup_convention_str(filegroup_Ptr filegroup_hdl)
110  {
111     CTimer::get("XIOS").resume();
112     bool isDefined = filegroup_hdl->convention_str.hasInheritedValue();
113     CTimer::get("XIOS").suspend();
114     return isDefined;
115  }
116
117
118  void cxios_set_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool cyclic)
119  {
120    CTimer::get("XIOS").resume();
121    filegroup_hdl->cyclic.setValue(cyclic);
122    CTimer::get("XIOS").suspend();
123  }
124
125  void cxios_get_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool* cyclic)
126  {
127    CTimer::get("XIOS").resume();
128    *cyclic = filegroup_hdl->cyclic.getInheritedValue();
129    CTimer::get("XIOS").suspend();
130  }
131
132  bool cxios_is_defined_filegroup_cyclic(filegroup_Ptr filegroup_hdl)
133  {
134     CTimer::get("XIOS").resume();
135     bool isDefined = filegroup_hdl->cyclic.hasInheritedValue();
136     CTimer::get("XIOS").suspend();
137     return isDefined;
138  }
139
140
141  void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size)
142  {
143    std::string description_str;
144    if (!cstr2string(description, description_size, description_str)) return;
145    CTimer::get("XIOS").resume();
146    filegroup_hdl->description.setValue(description_str);
147    CTimer::get("XIOS").suspend();
148  }
149
150  void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)
151  {
152    CTimer::get("XIOS").resume();
153    if (!string_copy(filegroup_hdl->description.getInheritedValue(), description, description_size))
154      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", << "Input string is too short");
155    CTimer::get("XIOS").suspend();
156  }
157
158  bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl)
159  {
160     CTimer::get("XIOS").resume();
161     bool isDefined = filegroup_hdl->description.hasInheritedValue();
162     CTimer::get("XIOS").suspend();
163     return isDefined;
164  }
165
166
167  void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled)
168  {
169    CTimer::get("XIOS").resume();
170    filegroup_hdl->enabled.setValue(enabled);
171    CTimer::get("XIOS").suspend();
172  }
173
174  void cxios_get_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool* enabled)
175  {
176    CTimer::get("XIOS").resume();
177    *enabled = filegroup_hdl->enabled.getInheritedValue();
178    CTimer::get("XIOS").suspend();
179  }
180
181  bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl)
182  {
183     CTimer::get("XIOS").resume();
184     bool isDefined = filegroup_hdl->enabled.hasInheritedValue();
185     CTimer::get("XIOS").suspend();
186     return isDefined;
187  }
188
189
190  void cxios_set_filegroup_format(filegroup_Ptr filegroup_hdl, const char * format, int format_size)
191  {
192    std::string format_str;
193    if (!cstr2string(format, format_size, format_str)) return;
194    CTimer::get("XIOS").resume();
195    filegroup_hdl->format.fromString(format_str);
196    CTimer::get("XIOS").suspend();
197  }
198
199  void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)
200  {
201    CTimer::get("XIOS").resume();
202    if (!string_copy(filegroup_hdl->format.getInheritedStringValue(), format, format_size))
203      ERROR("void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)", << "Input string is too short");
204    CTimer::get("XIOS").suspend();
205  }
206
207  bool cxios_is_defined_filegroup_format(filegroup_Ptr filegroup_hdl)
208  {
209     CTimer::get("XIOS").resume();
210     bool isDefined = filegroup_hdl->format.hasInheritedValue();
211     CTimer::get("XIOS").suspend();
212     return isDefined;
213  }
214
215
216  void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size)
217  {
218    std::string group_ref_str;
219    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
220    CTimer::get("XIOS").resume();
221    filegroup_hdl->group_ref.setValue(group_ref_str);
222    CTimer::get("XIOS").suspend();
223  }
224
225  void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)
226  {
227    CTimer::get("XIOS").resume();
228    if (!string_copy(filegroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size))
229      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short");
230    CTimer::get("XIOS").suspend();
231  }
232
233  bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl)
234  {
235     CTimer::get("XIOS").resume();
236     bool isDefined = filegroup_hdl->group_ref.hasInheritedValue();
237     CTimer::get("XIOS").suspend();
238     return isDefined;
239  }
240
241
242  void cxios_set_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int min_digits)
243  {
244    CTimer::get("XIOS").resume();
245    filegroup_hdl->min_digits.setValue(min_digits);
246    CTimer::get("XIOS").suspend();
247  }
248
249  void cxios_get_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int* min_digits)
250  {
251    CTimer::get("XIOS").resume();
252    *min_digits = filegroup_hdl->min_digits.getInheritedValue();
253    CTimer::get("XIOS").suspend();
254  }
255
256  bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl)
257  {
258     CTimer::get("XIOS").resume();
259     bool isDefined = filegroup_hdl->min_digits.hasInheritedValue();
260     CTimer::get("XIOS").suspend();
261     return isDefined;
262  }
263
264
265  void cxios_set_filegroup_mode(filegroup_Ptr filegroup_hdl, const char * mode, int mode_size)
266  {
267    std::string mode_str;
268    if (!cstr2string(mode, mode_size, mode_str)) return;
269    CTimer::get("XIOS").resume();
270    filegroup_hdl->mode.fromString(mode_str);
271    CTimer::get("XIOS").suspend();
272  }
273
274  void cxios_get_filegroup_mode(filegroup_Ptr filegroup_hdl, char * mode, int mode_size)
275  {
276    CTimer::get("XIOS").resume();
277    if (!string_copy(filegroup_hdl->mode.getInheritedStringValue(), mode, mode_size))
278      ERROR("void cxios_get_filegroup_mode(filegroup_Ptr filegroup_hdl, char * mode, int mode_size)", << "Input string is too short");
279    CTimer::get("XIOS").suspend();
280  }
281
282  bool cxios_is_defined_filegroup_mode(filegroup_Ptr filegroup_hdl)
283  {
284     CTimer::get("XIOS").resume();
285     bool isDefined = filegroup_hdl->mode.hasInheritedValue();
286     CTimer::get("XIOS").suspend();
287     return isDefined;
288  }
289
290
291  void cxios_set_filegroup_name(filegroup_Ptr filegroup_hdl, const char * name, int name_size)
292  {
293    std::string name_str;
294    if (!cstr2string(name, name_size, name_str)) return;
295    CTimer::get("XIOS").resume();
296    filegroup_hdl->name.setValue(name_str);
297    CTimer::get("XIOS").suspend();
298  }
299
300  void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)
301  {
302    CTimer::get("XIOS").resume();
303    if (!string_copy(filegroup_hdl->name.getInheritedValue(), name, name_size))
304      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", << "Input string is too short");
305    CTimer::get("XIOS").suspend();
306  }
307
308  bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl)
309  {
310     CTimer::get("XIOS").resume();
311     bool isDefined = filegroup_hdl->name.hasInheritedValue();
312     CTimer::get("XIOS").suspend();
313     return isDefined;
314  }
315
316
317  void cxios_set_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, const char * name_suffix, int name_suffix_size)
318  {
319    std::string name_suffix_str;
320    if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return;
321    CTimer::get("XIOS").resume();
322    filegroup_hdl->name_suffix.setValue(name_suffix_str);
323    CTimer::get("XIOS").suspend();
324  }
325
326  void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)
327  {
328    CTimer::get("XIOS").resume();
329    if (!string_copy(filegroup_hdl->name_suffix.getInheritedValue(), name_suffix, name_suffix_size))
330      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", << "Input string is too short");
331    CTimer::get("XIOS").suspend();
332  }
333
334  bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl)
335  {
336     CTimer::get("XIOS").resume();
337     bool isDefined = filegroup_hdl->name_suffix.hasInheritedValue();
338     CTimer::get("XIOS").suspend();
339     return isDefined;
340  }
341
342
343  void cxios_set_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration output_freq_c)
344  {
345    CTimer::get("XIOS").resume();
346    filegroup_hdl->output_freq.allocate();
347    CDuration& output_freq = filegroup_hdl->output_freq.get();
348    output_freq.year = output_freq_c.year;
349    output_freq.month = output_freq_c.month;
350    output_freq.day = output_freq_c.day;
351    output_freq.hour = output_freq_c.hour;
352    output_freq.minute = output_freq_c.minute;
353    output_freq.second = output_freq_c.second;
354    output_freq.timestep = output_freq_c.timestep;
355    CTimer::get("XIOS").suspend();
356  }
357
358  void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration* output_freq_c)
359  {
360    CTimer::get("XIOS").resume();
361    CDuration output_freq = filegroup_hdl->output_freq.getInheritedValue();
362    output_freq_c->year = output_freq.year;
363    output_freq_c->month = output_freq.month;
364    output_freq_c->day = output_freq.day;
365    output_freq_c->hour = output_freq.hour;
366    output_freq_c->minute = output_freq.minute;
367    output_freq_c->second = output_freq.second;
368    output_freq_c->timestep = output_freq.timestep;
369    CTimer::get("XIOS").suspend();
370  }
371
372  bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl)
373  {
374     CTimer::get("XIOS").resume();
375     bool isDefined = filegroup_hdl->output_freq.hasInheritedValue();
376     CTimer::get("XIOS").suspend();
377     return isDefined;
378  }
379
380
381  void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level)
382  {
383    CTimer::get("XIOS").resume();
384    filegroup_hdl->output_level.setValue(output_level);
385    CTimer::get("XIOS").suspend();
386  }
387
388  void cxios_get_filegroup_output_level(filegroup_Ptr filegroup_hdl, int* output_level)
389  {
390    CTimer::get("XIOS").resume();
391    *output_level = filegroup_hdl->output_level.getInheritedValue();
392    CTimer::get("XIOS").suspend();
393  }
394
395  bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl)
396  {
397     CTimer::get("XIOS").resume();
398     bool isDefined = filegroup_hdl->output_level.hasInheritedValue();
399     CTimer::get("XIOS").suspend();
400     return isDefined;
401  }
402
403
404  void cxios_set_filegroup_par_access(filegroup_Ptr filegroup_hdl, const char * par_access, int par_access_size)
405  {
406    std::string par_access_str;
407    if (!cstr2string(par_access, par_access_size, par_access_str)) return;
408    CTimer::get("XIOS").resume();
409    filegroup_hdl->par_access.fromString(par_access_str);
410    CTimer::get("XIOS").suspend();
411  }
412
413  void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)
414  {
415    CTimer::get("XIOS").resume();
416    if (!string_copy(filegroup_hdl->par_access.getInheritedStringValue(), par_access, par_access_size))
417      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", << "Input string is too short");
418    CTimer::get("XIOS").suspend();
419  }
420
421  bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl)
422  {
423     CTimer::get("XIOS").resume();
424     bool isDefined = filegroup_hdl->par_access.hasInheritedValue();
425     CTimer::get("XIOS").suspend();
426     return isDefined;
427  }
428
429
430  void cxios_set_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int record_offset)
431  {
432    CTimer::get("XIOS").resume();
433    filegroup_hdl->record_offset.setValue(record_offset);
434    CTimer::get("XIOS").suspend();
435  }
436
437  void cxios_get_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int* record_offset)
438  {
439    CTimer::get("XIOS").resume();
440    *record_offset = filegroup_hdl->record_offset.getInheritedValue();
441    CTimer::get("XIOS").suspend();
442  }
443
444  bool cxios_is_defined_filegroup_record_offset(filegroup_Ptr filegroup_hdl)
445  {
446     CTimer::get("XIOS").resume();
447     bool isDefined = filegroup_hdl->record_offset.hasInheritedValue();
448     CTimer::get("XIOS").suspend();
449     return isDefined;
450  }
451
452
453  void cxios_set_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration split_freq_c)
454  {
455    CTimer::get("XIOS").resume();
456    filegroup_hdl->split_freq.allocate();
457    CDuration& split_freq = filegroup_hdl->split_freq.get();
458    split_freq.year = split_freq_c.year;
459    split_freq.month = split_freq_c.month;
460    split_freq.day = split_freq_c.day;
461    split_freq.hour = split_freq_c.hour;
462    split_freq.minute = split_freq_c.minute;
463    split_freq.second = split_freq_c.second;
464    split_freq.timestep = split_freq_c.timestep;
465    CTimer::get("XIOS").suspend();
466  }
467
468  void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration* split_freq_c)
469  {
470    CTimer::get("XIOS").resume();
471    CDuration split_freq = filegroup_hdl->split_freq.getInheritedValue();
472    split_freq_c->year = split_freq.year;
473    split_freq_c->month = split_freq.month;
474    split_freq_c->day = split_freq.day;
475    split_freq_c->hour = split_freq.hour;
476    split_freq_c->minute = split_freq.minute;
477    split_freq_c->second = split_freq.second;
478    split_freq_c->timestep = split_freq.timestep;
479    CTimer::get("XIOS").suspend();
480  }
481
482  bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl)
483  {
484     CTimer::get("XIOS").resume();
485     bool isDefined = filegroup_hdl->split_freq.hasInheritedValue();
486     CTimer::get("XIOS").suspend();
487     return isDefined;
488  }
489
490
491  void cxios_set_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, const char * split_freq_format, int split_freq_format_size)
492  {
493    std::string split_freq_format_str;
494    if (!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return;
495    CTimer::get("XIOS").resume();
496    filegroup_hdl->split_freq_format.setValue(split_freq_format_str);
497    CTimer::get("XIOS").suspend();
498  }
499
500  void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)
501  {
502    CTimer::get("XIOS").resume();
503    if (!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(), split_freq_format, split_freq_format_size))
504      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");
505    CTimer::get("XIOS").suspend();
506  }
507
508  bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl)
509  {
510     CTimer::get("XIOS").resume();
511     bool isDefined = filegroup_hdl->split_freq_format.hasInheritedValue();
512     CTimer::get("XIOS").suspend();
513     return isDefined;
514  }
515
516
517  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c)
518  {
519    CTimer::get("XIOS").resume();
520    filegroup_hdl->sync_freq.allocate();
521    CDuration& sync_freq = filegroup_hdl->sync_freq.get();
522    sync_freq.year = sync_freq_c.year;
523    sync_freq.month = sync_freq_c.month;
524    sync_freq.day = sync_freq_c.day;
525    sync_freq.hour = sync_freq_c.hour;
526    sync_freq.minute = sync_freq_c.minute;
527    sync_freq.second = sync_freq_c.second;
528    sync_freq.timestep = sync_freq_c.timestep;
529    CTimer::get("XIOS").suspend();
530  }
531
532  void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration* sync_freq_c)
533  {
534    CTimer::get("XIOS").resume();
535    CDuration sync_freq = filegroup_hdl->sync_freq.getInheritedValue();
536    sync_freq_c->year = sync_freq.year;
537    sync_freq_c->month = sync_freq.month;
538    sync_freq_c->day = sync_freq.day;
539    sync_freq_c->hour = sync_freq.hour;
540    sync_freq_c->minute = sync_freq.minute;
541    sync_freq_c->second = sync_freq.second;
542    sync_freq_c->timestep = sync_freq.timestep;
543    CTimer::get("XIOS").suspend();
544  }
545
546  bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl)
547  {
548     CTimer::get("XIOS").resume();
549     bool isDefined = filegroup_hdl->sync_freq.hasInheritedValue();
550     CTimer::get("XIOS").suspend();
551     return isDefined;
552  }
553
554
555  void cxios_set_filegroup_time_counter(filegroup_Ptr filegroup_hdl, const char * time_counter, int time_counter_size)
556  {
557    std::string time_counter_str;
558    if (!cstr2string(time_counter, time_counter_size, time_counter_str)) return;
559    CTimer::get("XIOS").resume();
560    filegroup_hdl->time_counter.fromString(time_counter_str);
561    CTimer::get("XIOS").suspend();
562  }
563
564  void cxios_get_filegroup_time_counter(filegroup_Ptr filegroup_hdl, char * time_counter, int time_counter_size)
565  {
566    CTimer::get("XIOS").resume();
567    if (!string_copy(filegroup_hdl->time_counter.getInheritedStringValue(), time_counter, time_counter_size))
568      ERROR("void cxios_get_filegroup_time_counter(filegroup_Ptr filegroup_hdl, char * time_counter, int time_counter_size)", << "Input string is too short");
569    CTimer::get("XIOS").suspend();
570  }
571
572  bool cxios_is_defined_filegroup_time_counter(filegroup_Ptr filegroup_hdl)
573  {
574     CTimer::get("XIOS").resume();
575     bool isDefined = filegroup_hdl->time_counter.hasInheritedValue();
576     CTimer::get("XIOS").suspend();
577     return isDefined;
578  }
579
580
581  void cxios_set_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl, const char * time_counter_name, int time_counter_name_size)
582  {
583    std::string time_counter_name_str;
584    if (!cstr2string(time_counter_name, time_counter_name_size, time_counter_name_str)) return;
585    CTimer::get("XIOS").resume();
586    filegroup_hdl->time_counter_name.setValue(time_counter_name_str);
587    CTimer::get("XIOS").suspend();
588  }
589
590  void cxios_get_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl, char * time_counter_name, int time_counter_name_size)
591  {
592    CTimer::get("XIOS").resume();
593    if (!string_copy(filegroup_hdl->time_counter_name.getInheritedValue(), time_counter_name, time_counter_name_size))
594      ERROR("void cxios_get_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl, char * time_counter_name, int time_counter_name_size)", << "Input string is too short");
595    CTimer::get("XIOS").suspend();
596  }
597
598  bool cxios_is_defined_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl)
599  {
600     CTimer::get("XIOS").resume();
601     bool isDefined = filegroup_hdl->time_counter_name.hasInheritedValue();
602     CTimer::get("XIOS").suspend();
603     return isDefined;
604  }
605
606
607  void cxios_set_filegroup_time_stamp_format(filegroup_Ptr filegroup_hdl, const char * time_stamp_format, int time_stamp_format_size)
608  {
609    std::string time_stamp_format_str;
610    if (!cstr2string(time_stamp_format, time_stamp_format_size, time_stamp_format_str)) return;
611    CTimer::get("XIOS").resume();
612    filegroup_hdl->time_stamp_format.setValue(time_stamp_format_str);
613    CTimer::get("XIOS").suspend();
614  }
615
616  void cxios_get_filegroup_time_stamp_format(filegroup_Ptr filegroup_hdl, char * time_stamp_format, int time_stamp_format_size)
617  {
618    CTimer::get("XIOS").resume();
619    if (!string_copy(filegroup_hdl->time_stamp_format.getInheritedValue(), time_stamp_format, time_stamp_format_size))
620      ERROR("void cxios_get_filegroup_time_stamp_format(filegroup_Ptr filegroup_hdl, char * time_stamp_format, int time_stamp_format_size)", << "Input string is too short");
621    CTimer::get("XIOS").suspend();
622  }
623
624  bool cxios_is_defined_filegroup_time_stamp_format(filegroup_Ptr filegroup_hdl)
625  {
626     CTimer::get("XIOS").resume();
627     bool isDefined = filegroup_hdl->time_stamp_format.hasInheritedValue();
628     CTimer::get("XIOS").suspend();
629     return isDefined;
630  }
631
632
633  void cxios_set_filegroup_time_stamp_name(filegroup_Ptr filegroup_hdl, const char * time_stamp_name, int time_stamp_name_size)
634  {
635    std::string time_stamp_name_str;
636    if (!cstr2string(time_stamp_name, time_stamp_name_size, time_stamp_name_str)) return;
637    CTimer::get("XIOS").resume();
638    filegroup_hdl->time_stamp_name.setValue(time_stamp_name_str);
639    CTimer::get("XIOS").suspend();
640  }
641
642  void cxios_get_filegroup_time_stamp_name(filegroup_Ptr filegroup_hdl, char * time_stamp_name, int time_stamp_name_size)
643  {
644    CTimer::get("XIOS").resume();
645    if (!string_copy(filegroup_hdl->time_stamp_name.getInheritedValue(), time_stamp_name, time_stamp_name_size))
646      ERROR("void cxios_get_filegroup_time_stamp_name(filegroup_Ptr filegroup_hdl, char * time_stamp_name, int time_stamp_name_size)", << "Input string is too short");
647    CTimer::get("XIOS").suspend();
648  }
649
650  bool cxios_is_defined_filegroup_time_stamp_name(filegroup_Ptr filegroup_hdl)
651  {
652     CTimer::get("XIOS").resume();
653     bool isDefined = filegroup_hdl->time_stamp_name.hasInheritedValue();
654     CTimer::get("XIOS").suspend();
655     return isDefined;
656  }
657
658
659  void cxios_set_filegroup_time_units(filegroup_Ptr filegroup_hdl, const char * time_units, int time_units_size)
660  {
661    std::string time_units_str;
662    if (!cstr2string(time_units, time_units_size, time_units_str)) return;
663    CTimer::get("XIOS").resume();
664    filegroup_hdl->time_units.fromString(time_units_str);
665    CTimer::get("XIOS").suspend();
666  }
667
668  void cxios_get_filegroup_time_units(filegroup_Ptr filegroup_hdl, char * time_units, int time_units_size)
669  {
670    CTimer::get("XIOS").resume();
671    if (!string_copy(filegroup_hdl->time_units.getInheritedStringValue(), time_units, time_units_size))
672      ERROR("void cxios_get_filegroup_time_units(filegroup_Ptr filegroup_hdl, char * time_units, int time_units_size)", << "Input string is too short");
673    CTimer::get("XIOS").suspend();
674  }
675
676  bool cxios_is_defined_filegroup_time_units(filegroup_Ptr filegroup_hdl)
677  {
678     CTimer::get("XIOS").resume();
679     bool isDefined = filegroup_hdl->time_units.hasInheritedValue();
680     CTimer::get("XIOS").suspend();
681     return isDefined;
682  }
683
684
685  void cxios_set_filegroup_timeseries(filegroup_Ptr filegroup_hdl, const char * timeseries, int timeseries_size)
686  {
687    std::string timeseries_str;
688    if (!cstr2string(timeseries, timeseries_size, timeseries_str)) return;
689    CTimer::get("XIOS").resume();
690    filegroup_hdl->timeseries.fromString(timeseries_str);
691    CTimer::get("XIOS").suspend();
692  }
693
694  void cxios_get_filegroup_timeseries(filegroup_Ptr filegroup_hdl, char * timeseries, int timeseries_size)
695  {
696    CTimer::get("XIOS").resume();
697    if (!string_copy(filegroup_hdl->timeseries.getInheritedStringValue(), timeseries, timeseries_size))
698      ERROR("void cxios_get_filegroup_timeseries(filegroup_Ptr filegroup_hdl, char * timeseries, int timeseries_size)", << "Input string is too short");
699    CTimer::get("XIOS").suspend();
700  }
701
702  bool cxios_is_defined_filegroup_timeseries(filegroup_Ptr filegroup_hdl)
703  {
704     CTimer::get("XIOS").resume();
705     bool isDefined = filegroup_hdl->timeseries.hasInheritedValue();
706     CTimer::get("XIOS").suspend();
707     return isDefined;
708  }
709
710
711  void cxios_set_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, const char * ts_prefix, int ts_prefix_size)
712  {
713    std::string ts_prefix_str;
714    if (!cstr2string(ts_prefix, ts_prefix_size, ts_prefix_str)) return;
715    CTimer::get("XIOS").resume();
716    filegroup_hdl->ts_prefix.setValue(ts_prefix_str);
717    CTimer::get("XIOS").suspend();
718  }
719
720  void cxios_get_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, char * ts_prefix, int ts_prefix_size)
721  {
722    CTimer::get("XIOS").resume();
723    if (!string_copy(filegroup_hdl->ts_prefix.getInheritedValue(), ts_prefix, ts_prefix_size))
724      ERROR("void cxios_get_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, char * ts_prefix, int ts_prefix_size)", << "Input string is too short");
725    CTimer::get("XIOS").suspend();
726  }
727
728  bool cxios_is_defined_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl)
729  {
730     CTimer::get("XIOS").resume();
731     bool isDefined = filegroup_hdl->ts_prefix.hasInheritedValue();
732     CTimer::get("XIOS").suspend();
733     return isDefined;
734  }
735
736
737  void cxios_set_filegroup_type(filegroup_Ptr filegroup_hdl, const char * type, int type_size)
738  {
739    std::string type_str;
740    if (!cstr2string(type, type_size, type_str)) return;
741    CTimer::get("XIOS").resume();
742    filegroup_hdl->type.fromString(type_str);
743    CTimer::get("XIOS").suspend();
744  }
745
746  void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)
747  {
748    CTimer::get("XIOS").resume();
749    if (!string_copy(filegroup_hdl->type.getInheritedStringValue(), type, type_size))
750      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", << "Input string is too short");
751    CTimer::get("XIOS").suspend();
752  }
753
754  bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl)
755  {
756     CTimer::get("XIOS").resume();
757     bool isDefined = filegroup_hdl->type.hasInheritedValue();
758     CTimer::get("XIOS").suspend();
759     return isDefined;
760  }
761
762
763  void cxios_set_filegroup_uuid_format(filegroup_Ptr filegroup_hdl, const char * uuid_format, int uuid_format_size)
764  {
765    std::string uuid_format_str;
766    if (!cstr2string(uuid_format, uuid_format_size, uuid_format_str)) return;
767    CTimer::get("XIOS").resume();
768    filegroup_hdl->uuid_format.setValue(uuid_format_str);
769    CTimer::get("XIOS").suspend();
770  }
771
772  void cxios_get_filegroup_uuid_format(filegroup_Ptr filegroup_hdl, char * uuid_format, int uuid_format_size)
773  {
774    CTimer::get("XIOS").resume();
775    if (!string_copy(filegroup_hdl->uuid_format.getInheritedValue(), uuid_format, uuid_format_size))
776      ERROR("void cxios_get_filegroup_uuid_format(filegroup_Ptr filegroup_hdl, char * uuid_format, int uuid_format_size)", << "Input string is too short");
777    CTimer::get("XIOS").suspend();
778  }
779
780  bool cxios_is_defined_filegroup_uuid_format(filegroup_Ptr filegroup_hdl)
781  {
782     CTimer::get("XIOS").resume();
783     bool isDefined = filegroup_hdl->uuid_format.hasInheritedValue();
784     CTimer::get("XIOS").suspend();
785     return isDefined;
786  }
787
788
789  void cxios_set_filegroup_uuid_name(filegroup_Ptr filegroup_hdl, const char * uuid_name, int uuid_name_size)
790  {
791    std::string uuid_name_str;
792    if (!cstr2string(uuid_name, uuid_name_size, uuid_name_str)) return;
793    CTimer::get("XIOS").resume();
794    filegroup_hdl->uuid_name.setValue(uuid_name_str);
795    CTimer::get("XIOS").suspend();
796  }
797
798  void cxios_get_filegroup_uuid_name(filegroup_Ptr filegroup_hdl, char * uuid_name, int uuid_name_size)
799  {
800    CTimer::get("XIOS").resume();
801    if (!string_copy(filegroup_hdl->uuid_name.getInheritedValue(), uuid_name, uuid_name_size))
802      ERROR("void cxios_get_filegroup_uuid_name(filegroup_Ptr filegroup_hdl, char * uuid_name, int uuid_name_size)", << "Input string is too short");
803    CTimer::get("XIOS").suspend();
804  }
805
806  bool cxios_is_defined_filegroup_uuid_name(filegroup_Ptr filegroup_hdl)
807  {
808     CTimer::get("XIOS").resume();
809     bool isDefined = filegroup_hdl->uuid_name.hasInheritedValue();
810     CTimer::get("XIOS").suspend();
811     return isDefined;
812  }
813}
Note: See TracBrowser for help on using the repository browser.