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

Last change on this file since 903 was 891, checked in by mhnguyen, 8 years ago

Adding Fortran interface for reduce_axis_to_scalar

Test
+) On Curie
+) Only compilation

  • 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: 22.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 "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_cyclic(filegroup_Ptr filegroup_hdl, bool cyclic)
67  {
68    CTimer::get("XIOS").resume();
69    filegroup_hdl->cyclic.setValue(cyclic);
70    CTimer::get("XIOS").suspend();
71  }
72
73  void cxios_get_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool* cyclic)
74  {
75    CTimer::get("XIOS").resume();
76    *cyclic = filegroup_hdl->cyclic.getInheritedValue();
77    CTimer::get("XIOS").suspend();
78  }
79
80  bool cxios_is_defined_filegroup_cyclic(filegroup_Ptr filegroup_hdl)
81  {
82     CTimer::get("XIOS").resume();
83     bool isDefined = filegroup_hdl->cyclic.hasInheritedValue();
84     CTimer::get("XIOS").suspend();
85     return isDefined;
86  }
87
88
89  void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size)
90  {
91    std::string description_str;
92    if (!cstr2string(description, description_size, description_str)) return;
93    CTimer::get("XIOS").resume();
94    filegroup_hdl->description.setValue(description_str);
95    CTimer::get("XIOS").suspend();
96  }
97
98  void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)
99  {
100    CTimer::get("XIOS").resume();
101    if (!string_copy(filegroup_hdl->description.getInheritedValue(), description, description_size))
102      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", << "Input string is too short");
103    CTimer::get("XIOS").suspend();
104  }
105
106  bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl)
107  {
108     CTimer::get("XIOS").resume();
109     bool isDefined = filegroup_hdl->description.hasInheritedValue();
110     CTimer::get("XIOS").suspend();
111     return isDefined;
112  }
113
114
115  void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled)
116  {
117    CTimer::get("XIOS").resume();
118    filegroup_hdl->enabled.setValue(enabled);
119    CTimer::get("XIOS").suspend();
120  }
121
122  void cxios_get_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool* enabled)
123  {
124    CTimer::get("XIOS").resume();
125    *enabled = filegroup_hdl->enabled.getInheritedValue();
126    CTimer::get("XIOS").suspend();
127  }
128
129  bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl)
130  {
131     CTimer::get("XIOS").resume();
132     bool isDefined = filegroup_hdl->enabled.hasInheritedValue();
133     CTimer::get("XIOS").suspend();
134     return isDefined;
135  }
136
137
138  void cxios_set_filegroup_format(filegroup_Ptr filegroup_hdl, const char * format, int format_size)
139  {
140    std::string format_str;
141    if (!cstr2string(format, format_size, format_str)) return;
142    CTimer::get("XIOS").resume();
143    filegroup_hdl->format.fromString(format_str);
144    CTimer::get("XIOS").suspend();
145  }
146
147  void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)
148  {
149    CTimer::get("XIOS").resume();
150    if (!string_copy(filegroup_hdl->format.getInheritedStringValue(), format, format_size))
151      ERROR("void cxios_get_filegroup_format(filegroup_Ptr filegroup_hdl, char * format, int format_size)", << "Input string is too short");
152    CTimer::get("XIOS").suspend();
153  }
154
155  bool cxios_is_defined_filegroup_format(filegroup_Ptr filegroup_hdl)
156  {
157     CTimer::get("XIOS").resume();
158     bool isDefined = filegroup_hdl->format.hasInheritedValue();
159     CTimer::get("XIOS").suspend();
160     return isDefined;
161  }
162
163
164  void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size)
165  {
166    std::string group_ref_str;
167    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
168    CTimer::get("XIOS").resume();
169    filegroup_hdl->group_ref.setValue(group_ref_str);
170    CTimer::get("XIOS").suspend();
171  }
172
173  void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)
174  {
175    CTimer::get("XIOS").resume();
176    if (!string_copy(filegroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size))
177      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short");
178    CTimer::get("XIOS").suspend();
179  }
180
181  bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl)
182  {
183     CTimer::get("XIOS").resume();
184     bool isDefined = filegroup_hdl->group_ref.hasInheritedValue();
185     CTimer::get("XIOS").suspend();
186     return isDefined;
187  }
188
189
190  void cxios_set_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int min_digits)
191  {
192    CTimer::get("XIOS").resume();
193    filegroup_hdl->min_digits.setValue(min_digits);
194    CTimer::get("XIOS").suspend();
195  }
196
197  void cxios_get_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int* min_digits)
198  {
199    CTimer::get("XIOS").resume();
200    *min_digits = filegroup_hdl->min_digits.getInheritedValue();
201    CTimer::get("XIOS").suspend();
202  }
203
204  bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl)
205  {
206     CTimer::get("XIOS").resume();
207     bool isDefined = filegroup_hdl->min_digits.hasInheritedValue();
208     CTimer::get("XIOS").suspend();
209     return isDefined;
210  }
211
212
213  void cxios_set_filegroup_mode(filegroup_Ptr filegroup_hdl, const char * mode, int mode_size)
214  {
215    std::string mode_str;
216    if (!cstr2string(mode, mode_size, mode_str)) return;
217    CTimer::get("XIOS").resume();
218    filegroup_hdl->mode.fromString(mode_str);
219    CTimer::get("XIOS").suspend();
220  }
221
222  void cxios_get_filegroup_mode(filegroup_Ptr filegroup_hdl, char * mode, int mode_size)
223  {
224    CTimer::get("XIOS").resume();
225    if (!string_copy(filegroup_hdl->mode.getInheritedStringValue(), mode, mode_size))
226      ERROR("void cxios_get_filegroup_mode(filegroup_Ptr filegroup_hdl, char * mode, int mode_size)", << "Input string is too short");
227    CTimer::get("XIOS").suspend();
228  }
229
230  bool cxios_is_defined_filegroup_mode(filegroup_Ptr filegroup_hdl)
231  {
232     CTimer::get("XIOS").resume();
233     bool isDefined = filegroup_hdl->mode.hasInheritedValue();
234     CTimer::get("XIOS").suspend();
235     return isDefined;
236  }
237
238
239  void cxios_set_filegroup_name(filegroup_Ptr filegroup_hdl, const char * name, int name_size)
240  {
241    std::string name_str;
242    if (!cstr2string(name, name_size, name_str)) return;
243    CTimer::get("XIOS").resume();
244    filegroup_hdl->name.setValue(name_str);
245    CTimer::get("XIOS").suspend();
246  }
247
248  void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)
249  {
250    CTimer::get("XIOS").resume();
251    if (!string_copy(filegroup_hdl->name.getInheritedValue(), name, name_size))
252      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", << "Input string is too short");
253    CTimer::get("XIOS").suspend();
254  }
255
256  bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl)
257  {
258     CTimer::get("XIOS").resume();
259     bool isDefined = filegroup_hdl->name.hasInheritedValue();
260     CTimer::get("XIOS").suspend();
261     return isDefined;
262  }
263
264
265  void cxios_set_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, const char * name_suffix, int name_suffix_size)
266  {
267    std::string name_suffix_str;
268    if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return;
269    CTimer::get("XIOS").resume();
270    filegroup_hdl->name_suffix.setValue(name_suffix_str);
271    CTimer::get("XIOS").suspend();
272  }
273
274  void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)
275  {
276    CTimer::get("XIOS").resume();
277    if (!string_copy(filegroup_hdl->name_suffix.getInheritedValue(), name_suffix, name_suffix_size))
278      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", << "Input string is too short");
279    CTimer::get("XIOS").suspend();
280  }
281
282  bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl)
283  {
284     CTimer::get("XIOS").resume();
285     bool isDefined = filegroup_hdl->name_suffix.hasInheritedValue();
286     CTimer::get("XIOS").suspend();
287     return isDefined;
288  }
289
290
291  void cxios_set_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration output_freq_c)
292  {
293    CTimer::get("XIOS").resume();
294    filegroup_hdl->output_freq.allocate();
295    CDuration& output_freq = filegroup_hdl->output_freq.get();
296    output_freq.year = output_freq_c.year;
297    output_freq.month = output_freq_c.month;
298    output_freq.day = output_freq_c.day;
299    output_freq.hour = output_freq_c.hour;
300    output_freq.minute = output_freq_c.minute;
301    output_freq.second = output_freq_c.second;
302    output_freq.timestep = output_freq_c.timestep;
303    CTimer::get("XIOS").suspend();
304  }
305
306  void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, cxios_duration* output_freq_c)
307  {
308    CTimer::get("XIOS").resume();
309    CDuration output_freq = filegroup_hdl->output_freq.getInheritedValue();
310    output_freq_c->year = output_freq.year;
311    output_freq_c->month = output_freq.month;
312    output_freq_c->day = output_freq.day;
313    output_freq_c->hour = output_freq.hour;
314    output_freq_c->minute = output_freq.minute;
315    output_freq_c->second = output_freq.second;
316    output_freq_c->timestep = output_freq.timestep;
317    CTimer::get("XIOS").suspend();
318  }
319
320  bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl)
321  {
322     CTimer::get("XIOS").resume();
323     bool isDefined = filegroup_hdl->output_freq.hasInheritedValue();
324     CTimer::get("XIOS").suspend();
325     return isDefined;
326  }
327
328
329  void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level)
330  {
331    CTimer::get("XIOS").resume();
332    filegroup_hdl->output_level.setValue(output_level);
333    CTimer::get("XIOS").suspend();
334  }
335
336  void cxios_get_filegroup_output_level(filegroup_Ptr filegroup_hdl, int* output_level)
337  {
338    CTimer::get("XIOS").resume();
339    *output_level = filegroup_hdl->output_level.getInheritedValue();
340    CTimer::get("XIOS").suspend();
341  }
342
343  bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl)
344  {
345     CTimer::get("XIOS").resume();
346     bool isDefined = filegroup_hdl->output_level.hasInheritedValue();
347     CTimer::get("XIOS").suspend();
348     return isDefined;
349  }
350
351
352  void cxios_set_filegroup_par_access(filegroup_Ptr filegroup_hdl, const char * par_access, int par_access_size)
353  {
354    std::string par_access_str;
355    if (!cstr2string(par_access, par_access_size, par_access_str)) return;
356    CTimer::get("XIOS").resume();
357    filegroup_hdl->par_access.fromString(par_access_str);
358    CTimer::get("XIOS").suspend();
359  }
360
361  void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)
362  {
363    CTimer::get("XIOS").resume();
364    if (!string_copy(filegroup_hdl->par_access.getInheritedStringValue(), par_access, par_access_size))
365      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", << "Input string is too short");
366    CTimer::get("XIOS").suspend();
367  }
368
369  bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl)
370  {
371     CTimer::get("XIOS").resume();
372     bool isDefined = filegroup_hdl->par_access.hasInheritedValue();
373     CTimer::get("XIOS").suspend();
374     return isDefined;
375  }
376
377
378  void cxios_set_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int record_offset)
379  {
380    CTimer::get("XIOS").resume();
381    filegroup_hdl->record_offset.setValue(record_offset);
382    CTimer::get("XIOS").suspend();
383  }
384
385  void cxios_get_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int* record_offset)
386  {
387    CTimer::get("XIOS").resume();
388    *record_offset = filegroup_hdl->record_offset.getInheritedValue();
389    CTimer::get("XIOS").suspend();
390  }
391
392  bool cxios_is_defined_filegroup_record_offset(filegroup_Ptr filegroup_hdl)
393  {
394     CTimer::get("XIOS").resume();
395     bool isDefined = filegroup_hdl->record_offset.hasInheritedValue();
396     CTimer::get("XIOS").suspend();
397     return isDefined;
398  }
399
400
401  void cxios_set_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration split_freq_c)
402  {
403    CTimer::get("XIOS").resume();
404    filegroup_hdl->split_freq.allocate();
405    CDuration& split_freq = filegroup_hdl->split_freq.get();
406    split_freq.year = split_freq_c.year;
407    split_freq.month = split_freq_c.month;
408    split_freq.day = split_freq_c.day;
409    split_freq.hour = split_freq_c.hour;
410    split_freq.minute = split_freq_c.minute;
411    split_freq.second = split_freq_c.second;
412    split_freq.timestep = split_freq_c.timestep;
413    CTimer::get("XIOS").suspend();
414  }
415
416  void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, cxios_duration* split_freq_c)
417  {
418    CTimer::get("XIOS").resume();
419    CDuration split_freq = filegroup_hdl->split_freq.getInheritedValue();
420    split_freq_c->year = split_freq.year;
421    split_freq_c->month = split_freq.month;
422    split_freq_c->day = split_freq.day;
423    split_freq_c->hour = split_freq.hour;
424    split_freq_c->minute = split_freq.minute;
425    split_freq_c->second = split_freq.second;
426    split_freq_c->timestep = split_freq.timestep;
427    CTimer::get("XIOS").suspend();
428  }
429
430  bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl)
431  {
432     CTimer::get("XIOS").resume();
433     bool isDefined = filegroup_hdl->split_freq.hasInheritedValue();
434     CTimer::get("XIOS").suspend();
435     return isDefined;
436  }
437
438
439  void cxios_set_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, const char * split_freq_format, int split_freq_format_size)
440  {
441    std::string split_freq_format_str;
442    if (!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return;
443    CTimer::get("XIOS").resume();
444    filegroup_hdl->split_freq_format.setValue(split_freq_format_str);
445    CTimer::get("XIOS").suspend();
446  }
447
448  void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)
449  {
450    CTimer::get("XIOS").resume();
451    if (!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(), split_freq_format, split_freq_format_size))
452      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");
453    CTimer::get("XIOS").suspend();
454  }
455
456  bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl)
457  {
458     CTimer::get("XIOS").resume();
459     bool isDefined = filegroup_hdl->split_freq_format.hasInheritedValue();
460     CTimer::get("XIOS").suspend();
461     return isDefined;
462  }
463
464
465  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c)
466  {
467    CTimer::get("XIOS").resume();
468    filegroup_hdl->sync_freq.allocate();
469    CDuration& sync_freq = filegroup_hdl->sync_freq.get();
470    sync_freq.year = sync_freq_c.year;
471    sync_freq.month = sync_freq_c.month;
472    sync_freq.day = sync_freq_c.day;
473    sync_freq.hour = sync_freq_c.hour;
474    sync_freq.minute = sync_freq_c.minute;
475    sync_freq.second = sync_freq_c.second;
476    sync_freq.timestep = sync_freq_c.timestep;
477    CTimer::get("XIOS").suspend();
478  }
479
480  void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration* sync_freq_c)
481  {
482    CTimer::get("XIOS").resume();
483    CDuration sync_freq = filegroup_hdl->sync_freq.getInheritedValue();
484    sync_freq_c->year = sync_freq.year;
485    sync_freq_c->month = sync_freq.month;
486    sync_freq_c->day = sync_freq.day;
487    sync_freq_c->hour = sync_freq.hour;
488    sync_freq_c->minute = sync_freq.minute;
489    sync_freq_c->second = sync_freq.second;
490    sync_freq_c->timestep = sync_freq.timestep;
491    CTimer::get("XIOS").suspend();
492  }
493
494  bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl)
495  {
496     CTimer::get("XIOS").resume();
497     bool isDefined = filegroup_hdl->sync_freq.hasInheritedValue();
498     CTimer::get("XIOS").suspend();
499     return isDefined;
500  }
501
502
503  void cxios_set_filegroup_time_counter(filegroup_Ptr filegroup_hdl, const char * time_counter, int time_counter_size)
504  {
505    std::string time_counter_str;
506    if (!cstr2string(time_counter, time_counter_size, time_counter_str)) return;
507    CTimer::get("XIOS").resume();
508    filegroup_hdl->time_counter.fromString(time_counter_str);
509    CTimer::get("XIOS").suspend();
510  }
511
512  void cxios_get_filegroup_time_counter(filegroup_Ptr filegroup_hdl, char * time_counter, int time_counter_size)
513  {
514    CTimer::get("XIOS").resume();
515    if (!string_copy(filegroup_hdl->time_counter.getInheritedStringValue(), time_counter, time_counter_size))
516      ERROR("void cxios_get_filegroup_time_counter(filegroup_Ptr filegroup_hdl, char * time_counter, int time_counter_size)", << "Input string is too short");
517    CTimer::get("XIOS").suspend();
518  }
519
520  bool cxios_is_defined_filegroup_time_counter(filegroup_Ptr filegroup_hdl)
521  {
522     CTimer::get("XIOS").resume();
523     bool isDefined = filegroup_hdl->time_counter.hasInheritedValue();
524     CTimer::get("XIOS").suspend();
525     return isDefined;
526  }
527
528
529  void cxios_set_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl, const char * time_counter_name, int time_counter_name_size)
530  {
531    std::string time_counter_name_str;
532    if (!cstr2string(time_counter_name, time_counter_name_size, time_counter_name_str)) return;
533    CTimer::get("XIOS").resume();
534    filegroup_hdl->time_counter_name.setValue(time_counter_name_str);
535    CTimer::get("XIOS").suspend();
536  }
537
538  void cxios_get_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl, char * time_counter_name, int time_counter_name_size)
539  {
540    CTimer::get("XIOS").resume();
541    if (!string_copy(filegroup_hdl->time_counter_name.getInheritedValue(), time_counter_name, time_counter_name_size))
542      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");
543    CTimer::get("XIOS").suspend();
544  }
545
546  bool cxios_is_defined_filegroup_time_counter_name(filegroup_Ptr filegroup_hdl)
547  {
548     CTimer::get("XIOS").resume();
549     bool isDefined = filegroup_hdl->time_counter_name.hasInheritedValue();
550     CTimer::get("XIOS").suspend();
551     return isDefined;
552  }
553
554
555  void cxios_set_filegroup_timeseries(filegroup_Ptr filegroup_hdl, const char * timeseries, int timeseries_size)
556  {
557    std::string timeseries_str;
558    if (!cstr2string(timeseries, timeseries_size, timeseries_str)) return;
559    CTimer::get("XIOS").resume();
560    filegroup_hdl->timeseries.fromString(timeseries_str);
561    CTimer::get("XIOS").suspend();
562  }
563
564  void cxios_get_filegroup_timeseries(filegroup_Ptr filegroup_hdl, char * timeseries, int timeseries_size)
565  {
566    CTimer::get("XIOS").resume();
567    if (!string_copy(filegroup_hdl->timeseries.getInheritedStringValue(), timeseries, timeseries_size))
568      ERROR("void cxios_get_filegroup_timeseries(filegroup_Ptr filegroup_hdl, char * timeseries, int timeseries_size)", << "Input string is too short");
569    CTimer::get("XIOS").suspend();
570  }
571
572  bool cxios_is_defined_filegroup_timeseries(filegroup_Ptr filegroup_hdl)
573  {
574     CTimer::get("XIOS").resume();
575     bool isDefined = filegroup_hdl->timeseries.hasInheritedValue();
576     CTimer::get("XIOS").suspend();
577     return isDefined;
578  }
579
580
581  void cxios_set_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, const char * ts_prefix, int ts_prefix_size)
582  {
583    std::string ts_prefix_str;
584    if (!cstr2string(ts_prefix, ts_prefix_size, ts_prefix_str)) return;
585    CTimer::get("XIOS").resume();
586    filegroup_hdl->ts_prefix.setValue(ts_prefix_str);
587    CTimer::get("XIOS").suspend();
588  }
589
590  void cxios_get_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, char * ts_prefix, int ts_prefix_size)
591  {
592    CTimer::get("XIOS").resume();
593    if (!string_copy(filegroup_hdl->ts_prefix.getInheritedValue(), ts_prefix, ts_prefix_size))
594      ERROR("void cxios_get_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl, char * ts_prefix, int ts_prefix_size)", << "Input string is too short");
595    CTimer::get("XIOS").suspend();
596  }
597
598  bool cxios_is_defined_filegroup_ts_prefix(filegroup_Ptr filegroup_hdl)
599  {
600     CTimer::get("XIOS").resume();
601     bool isDefined = filegroup_hdl->ts_prefix.hasInheritedValue();
602     CTimer::get("XIOS").suspend();
603     return isDefined;
604  }
605
606
607  void cxios_set_filegroup_type(filegroup_Ptr filegroup_hdl, const char * type, int type_size)
608  {
609    std::string type_str;
610    if (!cstr2string(type, type_size, type_str)) return;
611    CTimer::get("XIOS").resume();
612    filegroup_hdl->type.fromString(type_str);
613    CTimer::get("XIOS").suspend();
614  }
615
616  void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)
617  {
618    CTimer::get("XIOS").resume();
619    if (!string_copy(filegroup_hdl->type.getInheritedStringValue(), type, type_size))
620      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", << "Input string is too short");
621    CTimer::get("XIOS").suspend();
622  }
623
624  bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl)
625  {
626     CTimer::get("XIOS").resume();
627     bool isDefined = filegroup_hdl->type.hasInheritedValue();
628     CTimer::get("XIOS").suspend();
629     return isDefined;
630  }
631}
Note: See TracBrowser for help on using the repository browser.