source: XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icfilegroup_attr.cpp @ 1492

Last change on this file since 1492 was 1492, checked in by oabramkina, 6 years ago

Updating fortran interface for attributes that have been recently introduced and the following filters:

duplicate_scalar_to_axis
reduce_axis_to_axis
reduce_scalar_to_scalar
reorder_domain
temporal_splitting.

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