source: XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

Last change on this file was 1626, checked in by oabramkina, 3 years ago

Trunk: limiting the line length to 132 characters in the Fortran interface + updating the 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: 30.5 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                     *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include "xios.hpp"
7#include "attribute_template.hpp"
8#include "object_template.hpp"
9#include "group_template.hpp"
10#include "icutil.hpp"
11#include "icdate.hpp"
12#include "timer.hpp"
13#include "node_type.hpp"
14
15extern "C"
16{
17  typedef xios::CFieldGroup* fieldgroup_Ptr;
18
19  void cxios_set_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl, double add_offset)
20  {
21    CTimer::get("XIOS").resume();
22    fieldgroup_hdl->add_offset.setValue(add_offset);
23    CTimer::get("XIOS").suspend();
24  }
25
26  void cxios_get_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl, double* add_offset)
27  {
28    CTimer::get("XIOS").resume();
29    *add_offset = fieldgroup_hdl->add_offset.getInheritedValue();
30    CTimer::get("XIOS").suspend();
31  }
32
33  bool cxios_is_defined_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl)
34  {
35     CTimer::get("XIOS").resume();
36     bool isDefined = fieldgroup_hdl->add_offset.hasInheritedValue();
37     CTimer::get("XIOS").suspend();
38     return isDefined;
39  }
40
41
42  void cxios_set_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, const char * axis_ref, int axis_ref_size)
43  {
44    std::string axis_ref_str;
45    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
46    CTimer::get("XIOS").resume();
47    fieldgroup_hdl->axis_ref.setValue(axis_ref_str);
48    CTimer::get("XIOS").suspend();
49  }
50
51  void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)
52  {
53    CTimer::get("XIOS").resume();
54    if (!string_copy(fieldgroup_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size))
55      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short");
56    CTimer::get("XIOS").suspend();
57  }
58
59  bool cxios_is_defined_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl)
60  {
61     CTimer::get("XIOS").resume();
62     bool isDefined = fieldgroup_hdl->axis_ref.hasInheritedValue();
63     CTimer::get("XIOS").suspend();
64     return isDefined;
65  }
66
67
68  void cxios_set_fieldgroup_cell_methods(fieldgroup_Ptr fieldgroup_hdl, const char * cell_methods, int cell_methods_size)
69  {
70    std::string cell_methods_str;
71    if (!cstr2string(cell_methods, cell_methods_size, cell_methods_str)) return;
72    CTimer::get("XIOS").resume();
73    fieldgroup_hdl->cell_methods.setValue(cell_methods_str);
74    CTimer::get("XIOS").suspend();
75  }
76
77  void cxios_get_fieldgroup_cell_methods(fieldgroup_Ptr fieldgroup_hdl, char * cell_methods, int cell_methods_size)
78  {
79    CTimer::get("XIOS").resume();
80    if (!string_copy(fieldgroup_hdl->cell_methods.getInheritedValue(), cell_methods, cell_methods_size))
81      ERROR("void cxios_get_fieldgroup_cell_methods(fieldgroup_Ptr fieldgroup_hdl, char * cell_methods, int cell_methods_size)", << "Input string is too short");
82    CTimer::get("XIOS").suspend();
83  }
84
85  bool cxios_is_defined_fieldgroup_cell_methods(fieldgroup_Ptr fieldgroup_hdl)
86  {
87     CTimer::get("XIOS").resume();
88     bool isDefined = fieldgroup_hdl->cell_methods.hasInheritedValue();
89     CTimer::get("XIOS").suspend();
90     return isDefined;
91  }
92
93
94  void cxios_set_fieldgroup_cell_methods_mode(fieldgroup_Ptr fieldgroup_hdl, const char * cell_methods_mode, int cell_methods_mode_size)
95  {
96    std::string cell_methods_mode_str;
97    if (!cstr2string(cell_methods_mode, cell_methods_mode_size, cell_methods_mode_str)) return;
98    CTimer::get("XIOS").resume();
99    fieldgroup_hdl->cell_methods_mode.fromString(cell_methods_mode_str);
100    CTimer::get("XIOS").suspend();
101  }
102
103  void cxios_get_fieldgroup_cell_methods_mode(fieldgroup_Ptr fieldgroup_hdl, char * cell_methods_mode, int cell_methods_mode_size)
104  {
105    CTimer::get("XIOS").resume();
106    if (!string_copy(fieldgroup_hdl->cell_methods_mode.getInheritedStringValue(), cell_methods_mode, cell_methods_mode_size))
107      ERROR("void cxios_get_fieldgroup_cell_methods_mode(fieldgroup_Ptr fieldgroup_hdl, char * cell_methods_mode, int cell_methods_mode_size)", << "Input string is too short");
108    CTimer::get("XIOS").suspend();
109  }
110
111  bool cxios_is_defined_fieldgroup_cell_methods_mode(fieldgroup_Ptr fieldgroup_hdl)
112  {
113     CTimer::get("XIOS").resume();
114     bool isDefined = fieldgroup_hdl->cell_methods_mode.hasInheritedValue();
115     CTimer::get("XIOS").suspend();
116     return isDefined;
117  }
118
119
120  void cxios_set_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl, bool check_if_active)
121  {
122    CTimer::get("XIOS").resume();
123    fieldgroup_hdl->check_if_active.setValue(check_if_active);
124    CTimer::get("XIOS").suspend();
125  }
126
127  void cxios_get_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl, bool* check_if_active)
128  {
129    CTimer::get("XIOS").resume();
130    *check_if_active = fieldgroup_hdl->check_if_active.getInheritedValue();
131    CTimer::get("XIOS").suspend();
132  }
133
134  bool cxios_is_defined_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl)
135  {
136     CTimer::get("XIOS").resume();
137     bool isDefined = fieldgroup_hdl->check_if_active.hasInheritedValue();
138     CTimer::get("XIOS").suspend();
139     return isDefined;
140  }
141
142
143  void cxios_set_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, const char * comment, int comment_size)
144  {
145    std::string comment_str;
146    if (!cstr2string(comment, comment_size, comment_str)) return;
147    CTimer::get("XIOS").resume();
148    fieldgroup_hdl->comment.setValue(comment_str);
149    CTimer::get("XIOS").suspend();
150  }
151
152  void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)
153  {
154    CTimer::get("XIOS").resume();
155    if (!string_copy(fieldgroup_hdl->comment.getInheritedValue(), comment, comment_size))
156      ERROR("void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)", << "Input string is too short");
157    CTimer::get("XIOS").suspend();
158  }
159
160  bool cxios_is_defined_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl)
161  {
162     CTimer::get("XIOS").resume();
163     bool isDefined = fieldgroup_hdl->comment.hasInheritedValue();
164     CTimer::get("XIOS").suspend();
165     return isDefined;
166  }
167
168
169  void cxios_set_fieldgroup_compression_level(fieldgroup_Ptr fieldgroup_hdl, int compression_level)
170  {
171    CTimer::get("XIOS").resume();
172    fieldgroup_hdl->compression_level.setValue(compression_level);
173    CTimer::get("XIOS").suspend();
174  }
175
176  void cxios_get_fieldgroup_compression_level(fieldgroup_Ptr fieldgroup_hdl, int* compression_level)
177  {
178    CTimer::get("XIOS").resume();
179    *compression_level = fieldgroup_hdl->compression_level.getInheritedValue();
180    CTimer::get("XIOS").suspend();
181  }
182
183  bool cxios_is_defined_fieldgroup_compression_level(fieldgroup_Ptr fieldgroup_hdl)
184  {
185     CTimer::get("XIOS").resume();
186     bool isDefined = fieldgroup_hdl->compression_level.hasInheritedValue();
187     CTimer::get("XIOS").suspend();
188     return isDefined;
189  }
190
191
192  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
193  {
194    CTimer::get("XIOS").resume();
195    fieldgroup_hdl->default_value.setValue(default_value);
196    CTimer::get("XIOS").suspend();
197  }
198
199  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value)
200  {
201    CTimer::get("XIOS").resume();
202    *default_value = fieldgroup_hdl->default_value.getInheritedValue();
203    CTimer::get("XIOS").suspend();
204  }
205
206  bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl)
207  {
208     CTimer::get("XIOS").resume();
209     bool isDefined = fieldgroup_hdl->default_value.hasInheritedValue();
210     CTimer::get("XIOS").suspend();
211     return isDefined;
212  }
213
214
215  void cxios_set_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool detect_missing_value)
216  {
217    CTimer::get("XIOS").resume();
218    fieldgroup_hdl->detect_missing_value.setValue(detect_missing_value);
219    CTimer::get("XIOS").suspend();
220  }
221
222  void cxios_get_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool* detect_missing_value)
223  {
224    CTimer::get("XIOS").resume();
225    *detect_missing_value = fieldgroup_hdl->detect_missing_value.getInheritedValue();
226    CTimer::get("XIOS").suspend();
227  }
228
229  bool cxios_is_defined_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl)
230  {
231     CTimer::get("XIOS").resume();
232     bool isDefined = fieldgroup_hdl->detect_missing_value.hasInheritedValue();
233     CTimer::get("XIOS").suspend();
234     return isDefined;
235  }
236
237
238  void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, const char * domain_ref, int domain_ref_size)
239  {
240    std::string domain_ref_str;
241    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
242    CTimer::get("XIOS").resume();
243    fieldgroup_hdl->domain_ref.setValue(domain_ref_str);
244    CTimer::get("XIOS").suspend();
245  }
246
247  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)
248  {
249    CTimer::get("XIOS").resume();
250    if (!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size))
251      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short");
252    CTimer::get("XIOS").suspend();
253  }
254
255  bool cxios_is_defined_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl)
256  {
257     CTimer::get("XIOS").resume();
258     bool isDefined = fieldgroup_hdl->domain_ref.hasInheritedValue();
259     CTimer::get("XIOS").suspend();
260     return isDefined;
261  }
262
263
264  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
265  {
266    CTimer::get("XIOS").resume();
267    fieldgroup_hdl->enabled.setValue(enabled);
268    CTimer::get("XIOS").suspend();
269  }
270
271  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled)
272  {
273    CTimer::get("XIOS").resume();
274    *enabled = fieldgroup_hdl->enabled.getInheritedValue();
275    CTimer::get("XIOS").suspend();
276  }
277
278  bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl)
279  {
280     CTimer::get("XIOS").resume();
281     bool isDefined = fieldgroup_hdl->enabled.hasInheritedValue();
282     CTimer::get("XIOS").suspend();
283     return isDefined;
284  }
285
286
287  void cxios_set_fieldgroup_expr(fieldgroup_Ptr fieldgroup_hdl, const char * expr, int expr_size)
288  {
289    std::string expr_str;
290    if (!cstr2string(expr, expr_size, expr_str)) return;
291    CTimer::get("XIOS").resume();
292    fieldgroup_hdl->expr.setValue(expr_str);
293    CTimer::get("XIOS").suspend();
294  }
295
296  void cxios_get_fieldgroup_expr(fieldgroup_Ptr fieldgroup_hdl, char * expr, int expr_size)
297  {
298    CTimer::get("XIOS").resume();
299    if (!string_copy(fieldgroup_hdl->expr.getInheritedValue(), expr, expr_size))
300      ERROR("void cxios_get_fieldgroup_expr(fieldgroup_Ptr fieldgroup_hdl, char * expr, int expr_size)", << "Input string is too short");
301    CTimer::get("XIOS").suspend();
302  }
303
304  bool cxios_is_defined_fieldgroup_expr(fieldgroup_Ptr fieldgroup_hdl)
305  {
306     CTimer::get("XIOS").resume();
307     bool isDefined = fieldgroup_hdl->expr.hasInheritedValue();
308     CTimer::get("XIOS").suspend();
309     return isDefined;
310  }
311
312
313  void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, const char * field_ref, int field_ref_size)
314  {
315    std::string field_ref_str;
316    if (!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
317    CTimer::get("XIOS").resume();
318    fieldgroup_hdl->field_ref.setValue(field_ref_str);
319    CTimer::get("XIOS").suspend();
320  }
321
322  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)
323  {
324    CTimer::get("XIOS").resume();
325    if (!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(), field_ref, field_ref_size))
326      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", << "Input string is too short");
327    CTimer::get("XIOS").suspend();
328  }
329
330  bool cxios_is_defined_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl)
331  {
332     CTimer::get("XIOS").resume();
333     bool isDefined = fieldgroup_hdl->field_ref.hasInheritedValue();
334     CTimer::get("XIOS").suspend();
335     return isDefined;
336  }
337
338
339  void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, cxios_duration freq_offset_c)
340  {
341    CTimer::get("XIOS").resume();
342    fieldgroup_hdl->freq_offset.allocate();
343    CDuration& freq_offset = fieldgroup_hdl->freq_offset.get();
344    freq_offset.year = freq_offset_c.year;
345    freq_offset.month = freq_offset_c.month;
346    freq_offset.day = freq_offset_c.day;
347    freq_offset.hour = freq_offset_c.hour;
348    freq_offset.minute = freq_offset_c.minute;
349    freq_offset.second = freq_offset_c.second;
350    freq_offset.timestep = freq_offset_c.timestep;
351    CTimer::get("XIOS").suspend();
352  }
353
354  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, cxios_duration* freq_offset_c)
355  {
356    CTimer::get("XIOS").resume();
357    CDuration freq_offset = fieldgroup_hdl->freq_offset.getInheritedValue();
358    freq_offset_c->year = freq_offset.year;
359    freq_offset_c->month = freq_offset.month;
360    freq_offset_c->day = freq_offset.day;
361    freq_offset_c->hour = freq_offset.hour;
362    freq_offset_c->minute = freq_offset.minute;
363    freq_offset_c->second = freq_offset.second;
364    freq_offset_c->timestep = freq_offset.timestep;
365    CTimer::get("XIOS").suspend();
366  }
367
368  bool cxios_is_defined_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl)
369  {
370     CTimer::get("XIOS").resume();
371     bool isDefined = fieldgroup_hdl->freq_offset.hasInheritedValue();
372     CTimer::get("XIOS").suspend();
373     return isDefined;
374  }
375
376
377  void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, cxios_duration freq_op_c)
378  {
379    CTimer::get("XIOS").resume();
380    fieldgroup_hdl->freq_op.allocate();
381    CDuration& freq_op = fieldgroup_hdl->freq_op.get();
382    freq_op.year = freq_op_c.year;
383    freq_op.month = freq_op_c.month;
384    freq_op.day = freq_op_c.day;
385    freq_op.hour = freq_op_c.hour;
386    freq_op.minute = freq_op_c.minute;
387    freq_op.second = freq_op_c.second;
388    freq_op.timestep = freq_op_c.timestep;
389    CTimer::get("XIOS").suspend();
390  }
391
392  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, cxios_duration* freq_op_c)
393  {
394    CTimer::get("XIOS").resume();
395    CDuration freq_op = fieldgroup_hdl->freq_op.getInheritedValue();
396    freq_op_c->year = freq_op.year;
397    freq_op_c->month = freq_op.month;
398    freq_op_c->day = freq_op.day;
399    freq_op_c->hour = freq_op.hour;
400    freq_op_c->minute = freq_op.minute;
401    freq_op_c->second = freq_op.second;
402    freq_op_c->timestep = freq_op.timestep;
403    CTimer::get("XIOS").suspend();
404  }
405
406  bool cxios_is_defined_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl)
407  {
408     CTimer::get("XIOS").resume();
409     bool isDefined = fieldgroup_hdl->freq_op.hasInheritedValue();
410     CTimer::get("XIOS").suspend();
411     return isDefined;
412  }
413
414
415  void cxios_set_fieldgroup_grid_path(fieldgroup_Ptr fieldgroup_hdl, const char * grid_path, int grid_path_size)
416  {
417    std::string grid_path_str;
418    if (!cstr2string(grid_path, grid_path_size, grid_path_str)) return;
419    CTimer::get("XIOS").resume();
420    fieldgroup_hdl->grid_path.setValue(grid_path_str);
421    CTimer::get("XIOS").suspend();
422  }
423
424  void cxios_get_fieldgroup_grid_path(fieldgroup_Ptr fieldgroup_hdl, char * grid_path, int grid_path_size)
425  {
426    CTimer::get("XIOS").resume();
427    if (!string_copy(fieldgroup_hdl->grid_path.getInheritedValue(), grid_path, grid_path_size))
428      ERROR("void cxios_get_fieldgroup_grid_path(fieldgroup_Ptr fieldgroup_hdl, char * grid_path, int grid_path_size)", << "Input string is too short");
429    CTimer::get("XIOS").suspend();
430  }
431
432  bool cxios_is_defined_fieldgroup_grid_path(fieldgroup_Ptr fieldgroup_hdl)
433  {
434     CTimer::get("XIOS").resume();
435     bool isDefined = fieldgroup_hdl->grid_path.hasInheritedValue();
436     CTimer::get("XIOS").suspend();
437     return isDefined;
438  }
439
440
441  void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, const char * grid_ref, int grid_ref_size)
442  {
443    std::string grid_ref_str;
444    if (!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
445    CTimer::get("XIOS").resume();
446    fieldgroup_hdl->grid_ref.setValue(grid_ref_str);
447    CTimer::get("XIOS").suspend();
448  }
449
450  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)
451  {
452    CTimer::get("XIOS").resume();
453    if (!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(), grid_ref, grid_ref_size))
454      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", << "Input string is too short");
455    CTimer::get("XIOS").suspend();
456  }
457
458  bool cxios_is_defined_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl)
459  {
460     CTimer::get("XIOS").resume();
461     bool isDefined = fieldgroup_hdl->grid_ref.hasInheritedValue();
462     CTimer::get("XIOS").suspend();
463     return isDefined;
464  }
465
466
467  void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size)
468  {
469    std::string group_ref_str;
470    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
471    CTimer::get("XIOS").resume();
472    fieldgroup_hdl->group_ref.setValue(group_ref_str);
473    CTimer::get("XIOS").suspend();
474  }
475
476  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)
477  {
478    CTimer::get("XIOS").resume();
479    if (!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size))
480      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short");
481    CTimer::get("XIOS").suspend();
482  }
483
484  bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl)
485  {
486     CTimer::get("XIOS").resume();
487     bool isDefined = fieldgroup_hdl->group_ref.hasInheritedValue();
488     CTimer::get("XIOS").suspend();
489     return isDefined;
490  }
491
492
493  void cxios_set_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl, bool indexed_output)
494  {
495    CTimer::get("XIOS").resume();
496    fieldgroup_hdl->indexed_output.setValue(indexed_output);
497    CTimer::get("XIOS").suspend();
498  }
499
500  void cxios_get_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl, bool* indexed_output)
501  {
502    CTimer::get("XIOS").resume();
503    *indexed_output = fieldgroup_hdl->indexed_output.getInheritedValue();
504    CTimer::get("XIOS").suspend();
505  }
506
507  bool cxios_is_defined_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl)
508  {
509     CTimer::get("XIOS").resume();
510     bool isDefined = fieldgroup_hdl->indexed_output.hasInheritedValue();
511     CTimer::get("XIOS").suspend();
512     return isDefined;
513  }
514
515
516  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
517  {
518    CTimer::get("XIOS").resume();
519    fieldgroup_hdl->level.setValue(level);
520    CTimer::get("XIOS").suspend();
521  }
522
523  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level)
524  {
525    CTimer::get("XIOS").resume();
526    *level = fieldgroup_hdl->level.getInheritedValue();
527    CTimer::get("XIOS").suspend();
528  }
529
530  bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl)
531  {
532     CTimer::get("XIOS").resume();
533     bool isDefined = fieldgroup_hdl->level.hasInheritedValue();
534     CTimer::get("XIOS").suspend();
535     return isDefined;
536  }
537
538
539  void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size)
540  {
541    std::string long_name_str;
542    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
543    CTimer::get("XIOS").resume();
544    fieldgroup_hdl->long_name.setValue(long_name_str);
545    CTimer::get("XIOS").suspend();
546  }
547
548  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)
549  {
550    CTimer::get("XIOS").resume();
551    if (!string_copy(fieldgroup_hdl->long_name.getInheritedValue(), long_name, long_name_size))
552      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", << "Input string is too short");
553    CTimer::get("XIOS").suspend();
554  }
555
556  bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl)
557  {
558     CTimer::get("XIOS").resume();
559     bool isDefined = fieldgroup_hdl->long_name.hasInheritedValue();
560     CTimer::get("XIOS").suspend();
561     return isDefined;
562  }
563
564
565  void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size)
566  {
567    std::string name_str;
568    if (!cstr2string(name, name_size, name_str)) return;
569    CTimer::get("XIOS").resume();
570    fieldgroup_hdl->name.setValue(name_str);
571    CTimer::get("XIOS").suspend();
572  }
573
574  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)
575  {
576    CTimer::get("XIOS").resume();
577    if (!string_copy(fieldgroup_hdl->name.getInheritedValue(), name, name_size))
578      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", << "Input string is too short");
579    CTimer::get("XIOS").suspend();
580  }
581
582  bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl)
583  {
584     CTimer::get("XIOS").resume();
585     bool isDefined = fieldgroup_hdl->name.hasInheritedValue();
586     CTimer::get("XIOS").suspend();
587     return isDefined;
588  }
589
590
591  void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size)
592  {
593    std::string operation_str;
594    if (!cstr2string(operation, operation_size, operation_str)) return;
595    CTimer::get("XIOS").resume();
596    fieldgroup_hdl->operation.setValue(operation_str);
597    CTimer::get("XIOS").suspend();
598  }
599
600  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)
601  {
602    CTimer::get("XIOS").resume();
603    if (!string_copy(fieldgroup_hdl->operation.getInheritedValue(), operation, operation_size))
604      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", << "Input string is too short");
605    CTimer::get("XIOS").suspend();
606  }
607
608  bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl)
609  {
610     CTimer::get("XIOS").resume();
611     bool isDefined = fieldgroup_hdl->operation.hasInheritedValue();
612     CTimer::get("XIOS").suspend();
613     return isDefined;
614  }
615
616
617  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
618  {
619    CTimer::get("XIOS").resume();
620    fieldgroup_hdl->prec.setValue(prec);
621    CTimer::get("XIOS").suspend();
622  }
623
624  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec)
625  {
626    CTimer::get("XIOS").resume();
627    *prec = fieldgroup_hdl->prec.getInheritedValue();
628    CTimer::get("XIOS").suspend();
629  }
630
631  bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl)
632  {
633     CTimer::get("XIOS").resume();
634     bool isDefined = fieldgroup_hdl->prec.hasInheritedValue();
635     CTimer::get("XIOS").suspend();
636     return isDefined;
637  }
638
639
640  void cxios_set_fieldgroup_read_access(fieldgroup_Ptr fieldgroup_hdl, bool read_access)
641  {
642    CTimer::get("XIOS").resume();
643    fieldgroup_hdl->read_access.setValue(read_access);
644    CTimer::get("XIOS").suspend();
645  }
646
647  void cxios_get_fieldgroup_read_access(fieldgroup_Ptr fieldgroup_hdl, bool* read_access)
648  {
649    CTimer::get("XIOS").resume();
650    *read_access = fieldgroup_hdl->read_access.getInheritedValue();
651    CTimer::get("XIOS").suspend();
652  }
653
654  bool cxios_is_defined_fieldgroup_read_access(fieldgroup_Ptr fieldgroup_hdl)
655  {
656     CTimer::get("XIOS").resume();
657     bool isDefined = fieldgroup_hdl->read_access.hasInheritedValue();
658     CTimer::get("XIOS").suspend();
659     return isDefined;
660  }
661
662
663  void cxios_set_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, const char * scalar_ref, int scalar_ref_size)
664  {
665    std::string scalar_ref_str;
666    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
667    CTimer::get("XIOS").resume();
668    fieldgroup_hdl->scalar_ref.setValue(scalar_ref_str);
669    CTimer::get("XIOS").suspend();
670  }
671
672  void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size)
673  {
674    CTimer::get("XIOS").resume();
675    if (!string_copy(fieldgroup_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
676      ERROR("void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
677    CTimer::get("XIOS").suspend();
678  }
679
680  bool cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl)
681  {
682     CTimer::get("XIOS").resume();
683     bool isDefined = fieldgroup_hdl->scalar_ref.hasInheritedValue();
684     CTimer::get("XIOS").suspend();
685     return isDefined;
686  }
687
688
689  void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor)
690  {
691    CTimer::get("XIOS").resume();
692    fieldgroup_hdl->scale_factor.setValue(scale_factor);
693    CTimer::get("XIOS").suspend();
694  }
695
696  void cxios_get_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double* scale_factor)
697  {
698    CTimer::get("XIOS").resume();
699    *scale_factor = fieldgroup_hdl->scale_factor.getInheritedValue();
700    CTimer::get("XIOS").suspend();
701  }
702
703  bool cxios_is_defined_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl)
704  {
705     CTimer::get("XIOS").resume();
706     bool isDefined = fieldgroup_hdl->scale_factor.hasInheritedValue();
707     CTimer::get("XIOS").suspend();
708     return isDefined;
709  }
710
711
712  void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size)
713  {
714    std::string standard_name_str;
715    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
716    CTimer::get("XIOS").resume();
717    fieldgroup_hdl->standard_name.setValue(standard_name_str);
718    CTimer::get("XIOS").suspend();
719  }
720
721  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)
722  {
723    CTimer::get("XIOS").resume();
724    if (!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
725      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
726    CTimer::get("XIOS").suspend();
727  }
728
729  bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl)
730  {
731     CTimer::get("XIOS").resume();
732     bool isDefined = fieldgroup_hdl->standard_name.hasInheritedValue();
733     CTimer::get("XIOS").suspend();
734     return isDefined;
735  }
736
737
738  void cxios_set_fieldgroup_ts_enabled(fieldgroup_Ptr fieldgroup_hdl, bool ts_enabled)
739  {
740    CTimer::get("XIOS").resume();
741    fieldgroup_hdl->ts_enabled.setValue(ts_enabled);
742    CTimer::get("XIOS").suspend();
743  }
744
745  void cxios_get_fieldgroup_ts_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* ts_enabled)
746  {
747    CTimer::get("XIOS").resume();
748    *ts_enabled = fieldgroup_hdl->ts_enabled.getInheritedValue();
749    CTimer::get("XIOS").suspend();
750  }
751
752  bool cxios_is_defined_fieldgroup_ts_enabled(fieldgroup_Ptr fieldgroup_hdl)
753  {
754     CTimer::get("XIOS").resume();
755     bool isDefined = fieldgroup_hdl->ts_enabled.hasInheritedValue();
756     CTimer::get("XIOS").suspend();
757     return isDefined;
758  }
759
760
761  void cxios_set_fieldgroup_ts_split_freq(fieldgroup_Ptr fieldgroup_hdl, cxios_duration ts_split_freq_c)
762  {
763    CTimer::get("XIOS").resume();
764    fieldgroup_hdl->ts_split_freq.allocate();
765    CDuration& ts_split_freq = fieldgroup_hdl->ts_split_freq.get();
766    ts_split_freq.year = ts_split_freq_c.year;
767    ts_split_freq.month = ts_split_freq_c.month;
768    ts_split_freq.day = ts_split_freq_c.day;
769    ts_split_freq.hour = ts_split_freq_c.hour;
770    ts_split_freq.minute = ts_split_freq_c.minute;
771    ts_split_freq.second = ts_split_freq_c.second;
772    ts_split_freq.timestep = ts_split_freq_c.timestep;
773    CTimer::get("XIOS").suspend();
774  }
775
776  void cxios_get_fieldgroup_ts_split_freq(fieldgroup_Ptr fieldgroup_hdl, cxios_duration* ts_split_freq_c)
777  {
778    CTimer::get("XIOS").resume();
779    CDuration ts_split_freq = fieldgroup_hdl->ts_split_freq.getInheritedValue();
780    ts_split_freq_c->year = ts_split_freq.year;
781    ts_split_freq_c->month = ts_split_freq.month;
782    ts_split_freq_c->day = ts_split_freq.day;
783    ts_split_freq_c->hour = ts_split_freq.hour;
784    ts_split_freq_c->minute = ts_split_freq.minute;
785    ts_split_freq_c->second = ts_split_freq.second;
786    ts_split_freq_c->timestep = ts_split_freq.timestep;
787    CTimer::get("XIOS").suspend();
788  }
789
790  bool cxios_is_defined_fieldgroup_ts_split_freq(fieldgroup_Ptr fieldgroup_hdl)
791  {
792     CTimer::get("XIOS").resume();
793     bool isDefined = fieldgroup_hdl->ts_split_freq.hasInheritedValue();
794     CTimer::get("XIOS").suspend();
795     return isDefined;
796  }
797
798
799  void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size)
800  {
801    std::string unit_str;
802    if (!cstr2string(unit, unit_size, unit_str)) return;
803    CTimer::get("XIOS").resume();
804    fieldgroup_hdl->unit.setValue(unit_str);
805    CTimer::get("XIOS").suspend();
806  }
807
808  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)
809  {
810    CTimer::get("XIOS").resume();
811    if (!string_copy(fieldgroup_hdl->unit.getInheritedValue(), unit, unit_size))
812      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", << "Input string is too short");
813    CTimer::get("XIOS").suspend();
814  }
815
816  bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl)
817  {
818     CTimer::get("XIOS").resume();
819     bool isDefined = fieldgroup_hdl->unit.hasInheritedValue();
820     CTimer::get("XIOS").suspend();
821     return isDefined;
822  }
823
824
825  void cxios_set_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double valid_max)
826  {
827    CTimer::get("XIOS").resume();
828    fieldgroup_hdl->valid_max.setValue(valid_max);
829    CTimer::get("XIOS").suspend();
830  }
831
832  void cxios_get_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double* valid_max)
833  {
834    CTimer::get("XIOS").resume();
835    *valid_max = fieldgroup_hdl->valid_max.getInheritedValue();
836    CTimer::get("XIOS").suspend();
837  }
838
839  bool cxios_is_defined_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl)
840  {
841     CTimer::get("XIOS").resume();
842     bool isDefined = fieldgroup_hdl->valid_max.hasInheritedValue();
843     CTimer::get("XIOS").suspend();
844     return isDefined;
845  }
846
847
848  void cxios_set_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double valid_min)
849  {
850    CTimer::get("XIOS").resume();
851    fieldgroup_hdl->valid_min.setValue(valid_min);
852    CTimer::get("XIOS").suspend();
853  }
854
855  void cxios_get_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double* valid_min)
856  {
857    CTimer::get("XIOS").resume();
858    *valid_min = fieldgroup_hdl->valid_min.getInheritedValue();
859    CTimer::get("XIOS").suspend();
860  }
861
862  bool cxios_is_defined_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl)
863  {
864     CTimer::get("XIOS").resume();
865     bool isDefined = fieldgroup_hdl->valid_min.hasInheritedValue();
866     CTimer::get("XIOS").suspend();
867     return isDefined;
868  }
869}
Note: See TracBrowser for help on using the repository browser.