source: XIOS/dev/dev_trunk_omp/src/interface/c_attr/icfield_attr.cpp @ 1646

Last change on this file since 1646 was 1646, checked in by yushan, 5 years ago

branch merged with trunk @1645. arch file (ep&mpi) added for ADA

  • 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: 27.4 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::CField* field_Ptr;
18
19  void cxios_set_field_add_offset(field_Ptr field_hdl, double add_offset)
20  {
21    CTimer::get("XIOS").resume();
22    field_hdl->add_offset.setValue(add_offset);
23    CTimer::get("XIOS").suspend();
24  }
25
26  void cxios_get_field_add_offset(field_Ptr field_hdl, double* add_offset)
27  {
28    CTimer::get("XIOS").resume();
29    *add_offset = field_hdl->add_offset.getInheritedValue();
30    CTimer::get("XIOS").suspend();
31  }
32
33  bool cxios_is_defined_field_add_offset(field_Ptr field_hdl)
34  {
35     CTimer::get("XIOS").resume();
36     bool isDefined = field_hdl->add_offset.hasInheritedValue();
37     CTimer::get("XIOS").suspend();
38     return isDefined;
39  }
40
41
42  void cxios_set_field_axis_ref(field_Ptr field_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    field_hdl->axis_ref.setValue(axis_ref_str);
48    CTimer::get("XIOS").suspend();
49  }
50
51  void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)
52  {
53    CTimer::get("XIOS").resume();
54    if (!string_copy(field_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size))
55      ERROR("void cxios_get_field_axis_ref(field_Ptr field_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_field_axis_ref(field_Ptr field_hdl)
60  {
61     CTimer::get("XIOS").resume();
62     bool isDefined = field_hdl->axis_ref.hasInheritedValue();
63     CTimer::get("XIOS").suspend();
64     return isDefined;
65  }
66
67
68  void cxios_set_field_cell_methods(field_Ptr field_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    field_hdl->cell_methods.setValue(cell_methods_str);
74    CTimer::get("XIOS").suspend();
75  }
76
77  void cxios_get_field_cell_methods(field_Ptr field_hdl, char * cell_methods, int cell_methods_size)
78  {
79    CTimer::get("XIOS").resume();
80    if (!string_copy(field_hdl->cell_methods.getInheritedValue(), cell_methods, cell_methods_size))
81      ERROR("void cxios_get_field_cell_methods(field_Ptr field_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_field_cell_methods(field_Ptr field_hdl)
86  {
87     CTimer::get("XIOS").resume();
88     bool isDefined = field_hdl->cell_methods.hasInheritedValue();
89     CTimer::get("XIOS").suspend();
90     return isDefined;
91  }
92
93
94  void cxios_set_field_cell_methods_mode(field_Ptr field_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    field_hdl->cell_methods_mode.fromString(cell_methods_mode_str);
100    CTimer::get("XIOS").suspend();
101  }
102
103  void cxios_get_field_cell_methods_mode(field_Ptr field_hdl, char * cell_methods_mode, int cell_methods_mode_size)
104  {
105    CTimer::get("XIOS").resume();
106    if (!string_copy(field_hdl->cell_methods_mode.getInheritedStringValue(), cell_methods_mode, cell_methods_mode_size))
107      ERROR("void cxios_get_field_cell_methods_mode(field_Ptr field_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_field_cell_methods_mode(field_Ptr field_hdl)
112  {
113     CTimer::get("XIOS").resume();
114     bool isDefined = field_hdl->cell_methods_mode.hasInheritedValue();
115     CTimer::get("XIOS").suspend();
116     return isDefined;
117  }
118
119
120  void cxios_set_field_check_if_active(field_Ptr field_hdl, bool check_if_active)
121  {
122    CTimer::get("XIOS").resume();
123    field_hdl->check_if_active.setValue(check_if_active);
124    CTimer::get("XIOS").suspend();
125  }
126
127  void cxios_get_field_check_if_active(field_Ptr field_hdl, bool* check_if_active)
128  {
129    CTimer::get("XIOS").resume();
130    *check_if_active = field_hdl->check_if_active.getInheritedValue();
131    CTimer::get("XIOS").suspend();
132  }
133
134  bool cxios_is_defined_field_check_if_active(field_Ptr field_hdl)
135  {
136     CTimer::get("XIOS").resume();
137     bool isDefined = field_hdl->check_if_active.hasInheritedValue();
138     CTimer::get("XIOS").suspend();
139     return isDefined;
140  }
141
142
143  void cxios_set_field_comment(field_Ptr field_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    field_hdl->comment.setValue(comment_str);
149    CTimer::get("XIOS").suspend();
150  }
151
152  void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)
153  {
154    CTimer::get("XIOS").resume();
155    if (!string_copy(field_hdl->comment.getInheritedValue(), comment, comment_size))
156      ERROR("void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)", << "Input string is too short");
157    CTimer::get("XIOS").suspend();
158  }
159
160  bool cxios_is_defined_field_comment(field_Ptr field_hdl)
161  {
162     CTimer::get("XIOS").resume();
163     bool isDefined = field_hdl->comment.hasInheritedValue();
164     CTimer::get("XIOS").suspend();
165     return isDefined;
166  }
167
168
169  void cxios_set_field_compression_level(field_Ptr field_hdl, int compression_level)
170  {
171    CTimer::get("XIOS").resume();
172    field_hdl->compression_level.setValue(compression_level);
173    CTimer::get("XIOS").suspend();
174  }
175
176  void cxios_get_field_compression_level(field_Ptr field_hdl, int* compression_level)
177  {
178    CTimer::get("XIOS").resume();
179    *compression_level = field_hdl->compression_level.getInheritedValue();
180    CTimer::get("XIOS").suspend();
181  }
182
183  bool cxios_is_defined_field_compression_level(field_Ptr field_hdl)
184  {
185     CTimer::get("XIOS").resume();
186     bool isDefined = field_hdl->compression_level.hasInheritedValue();
187     CTimer::get("XIOS").suspend();
188     return isDefined;
189  }
190
191
192  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
193  {
194    CTimer::get("XIOS").resume();
195    field_hdl->default_value.setValue(default_value);
196    CTimer::get("XIOS").suspend();
197  }
198
199  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value)
200  {
201    CTimer::get("XIOS").resume();
202    *default_value = field_hdl->default_value.getInheritedValue();
203    CTimer::get("XIOS").suspend();
204  }
205
206  bool cxios_is_defined_field_default_value(field_Ptr field_hdl)
207  {
208     CTimer::get("XIOS").resume();
209     bool isDefined = field_hdl->default_value.hasInheritedValue();
210     CTimer::get("XIOS").suspend();
211     return isDefined;
212  }
213
214
215  void cxios_set_field_detect_missing_value(field_Ptr field_hdl, bool detect_missing_value)
216  {
217    CTimer::get("XIOS").resume();
218    field_hdl->detect_missing_value.setValue(detect_missing_value);
219    CTimer::get("XIOS").suspend();
220  }
221
222  void cxios_get_field_detect_missing_value(field_Ptr field_hdl, bool* detect_missing_value)
223  {
224    CTimer::get("XIOS").resume();
225    *detect_missing_value = field_hdl->detect_missing_value.getInheritedValue();
226    CTimer::get("XIOS").suspend();
227  }
228
229  bool cxios_is_defined_field_detect_missing_value(field_Ptr field_hdl)
230  {
231     CTimer::get("XIOS").resume();
232     bool isDefined = field_hdl->detect_missing_value.hasInheritedValue();
233     CTimer::get("XIOS").suspend();
234     return isDefined;
235  }
236
237
238  void cxios_set_field_domain_ref(field_Ptr field_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    field_hdl->domain_ref.setValue(domain_ref_str);
244    CTimer::get("XIOS").suspend();
245  }
246
247  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
248  {
249    CTimer::get("XIOS").resume();
250    if (!string_copy(field_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size))
251      ERROR("void cxios_get_field_domain_ref(field_Ptr field_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_field_domain_ref(field_Ptr field_hdl)
256  {
257     CTimer::get("XIOS").resume();
258     bool isDefined = field_hdl->domain_ref.hasInheritedValue();
259     CTimer::get("XIOS").suspend();
260     return isDefined;
261  }
262
263
264  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
265  {
266    CTimer::get("XIOS").resume();
267    field_hdl->enabled.setValue(enabled);
268    CTimer::get("XIOS").suspend();
269  }
270
271  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled)
272  {
273    CTimer::get("XIOS").resume();
274    *enabled = field_hdl->enabled.getInheritedValue();
275    CTimer::get("XIOS").suspend();
276  }
277
278  bool cxios_is_defined_field_enabled(field_Ptr field_hdl)
279  {
280     CTimer::get("XIOS").resume();
281     bool isDefined = field_hdl->enabled.hasInheritedValue();
282     CTimer::get("XIOS").suspend();
283     return isDefined;
284  }
285
286
287  void cxios_set_field_expr(field_Ptr field_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    field_hdl->expr.setValue(expr_str);
293    CTimer::get("XIOS").suspend();
294  }
295
296  void cxios_get_field_expr(field_Ptr field_hdl, char * expr, int expr_size)
297  {
298    CTimer::get("XIOS").resume();
299    if (!string_copy(field_hdl->expr.getInheritedValue(), expr, expr_size))
300      ERROR("void cxios_get_field_expr(field_Ptr field_hdl, char * expr, int expr_size)", << "Input string is too short");
301    CTimer::get("XIOS").suspend();
302  }
303
304  bool cxios_is_defined_field_expr(field_Ptr field_hdl)
305  {
306     CTimer::get("XIOS").resume();
307     bool isDefined = field_hdl->expr.hasInheritedValue();
308     CTimer::get("XIOS").suspend();
309     return isDefined;
310  }
311
312
313  void cxios_set_field_field_ref(field_Ptr field_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    field_hdl->field_ref.setValue(field_ref_str);
319    CTimer::get("XIOS").suspend();
320  }
321
322  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
323  {
324    CTimer::get("XIOS").resume();
325    if (!string_copy(field_hdl->field_ref.getInheritedValue(), field_ref, field_ref_size))
326      ERROR("void cxios_get_field_field_ref(field_Ptr field_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_field_field_ref(field_Ptr field_hdl)
331  {
332     CTimer::get("XIOS").resume();
333     bool isDefined = field_hdl->field_ref.hasInheritedValue();
334     CTimer::get("XIOS").suspend();
335     return isDefined;
336  }
337
338
339  void cxios_set_field_freq_offset(field_Ptr field_hdl, cxios_duration freq_offset_c)
340  {
341    CTimer::get("XIOS").resume();
342    field_hdl->freq_offset.allocate();
343    CDuration& freq_offset = field_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_field_freq_offset(field_Ptr field_hdl, cxios_duration* freq_offset_c)
355  {
356    CTimer::get("XIOS").resume();
357    CDuration freq_offset = field_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_field_freq_offset(field_Ptr field_hdl)
369  {
370     CTimer::get("XIOS").resume();
371     bool isDefined = field_hdl->freq_offset.hasInheritedValue();
372     CTimer::get("XIOS").suspend();
373     return isDefined;
374  }
375
376
377  void cxios_set_field_freq_op(field_Ptr field_hdl, cxios_duration freq_op_c)
378  {
379    CTimer::get("XIOS").resume();
380    field_hdl->freq_op.allocate();
381    CDuration& freq_op = field_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_field_freq_op(field_Ptr field_hdl, cxios_duration* freq_op_c)
393  {
394    CTimer::get("XIOS").resume();
395    CDuration freq_op = field_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_field_freq_op(field_Ptr field_hdl)
407  {
408     CTimer::get("XIOS").resume();
409     bool isDefined = field_hdl->freq_op.hasInheritedValue();
410     CTimer::get("XIOS").suspend();
411     return isDefined;
412  }
413
414
415  void cxios_set_field_grid_path(field_Ptr field_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    field_hdl->grid_path.setValue(grid_path_str);
421    CTimer::get("XIOS").suspend();
422  }
423
424  void cxios_get_field_grid_path(field_Ptr field_hdl, char * grid_path, int grid_path_size)
425  {
426    CTimer::get("XIOS").resume();
427    if (!string_copy(field_hdl->grid_path.getInheritedValue(), grid_path, grid_path_size))
428      ERROR("void cxios_get_field_grid_path(field_Ptr field_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_field_grid_path(field_Ptr field_hdl)
433  {
434     CTimer::get("XIOS").resume();
435     bool isDefined = field_hdl->grid_path.hasInheritedValue();
436     CTimer::get("XIOS").suspend();
437     return isDefined;
438  }
439
440
441  void cxios_set_field_grid_ref(field_Ptr field_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    field_hdl->grid_ref.setValue(grid_ref_str);
447    CTimer::get("XIOS").suspend();
448  }
449
450  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
451  {
452    CTimer::get("XIOS").resume();
453    if (!string_copy(field_hdl->grid_ref.getInheritedValue(), grid_ref, grid_ref_size))
454      ERROR("void cxios_get_field_grid_ref(field_Ptr field_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_field_grid_ref(field_Ptr field_hdl)
459  {
460     CTimer::get("XIOS").resume();
461     bool isDefined = field_hdl->grid_ref.hasInheritedValue();
462     CTimer::get("XIOS").suspend();
463     return isDefined;
464  }
465
466
467  void cxios_set_field_indexed_output(field_Ptr field_hdl, bool indexed_output)
468  {
469    CTimer::get("XIOS").resume();
470    field_hdl->indexed_output.setValue(indexed_output);
471    CTimer::get("XIOS").suspend();
472  }
473
474  void cxios_get_field_indexed_output(field_Ptr field_hdl, bool* indexed_output)
475  {
476    CTimer::get("XIOS").resume();
477    *indexed_output = field_hdl->indexed_output.getInheritedValue();
478    CTimer::get("XIOS").suspend();
479  }
480
481  bool cxios_is_defined_field_indexed_output(field_Ptr field_hdl)
482  {
483     CTimer::get("XIOS").resume();
484     bool isDefined = field_hdl->indexed_output.hasInheritedValue();
485     CTimer::get("XIOS").suspend();
486     return isDefined;
487  }
488
489
490  void cxios_set_field_level(field_Ptr field_hdl, int level)
491  {
492    CTimer::get("XIOS").resume();
493    field_hdl->level.setValue(level);
494    CTimer::get("XIOS").suspend();
495  }
496
497  void cxios_get_field_level(field_Ptr field_hdl, int* level)
498  {
499    CTimer::get("XIOS").resume();
500    *level = field_hdl->level.getInheritedValue();
501    CTimer::get("XIOS").suspend();
502  }
503
504  bool cxios_is_defined_field_level(field_Ptr field_hdl)
505  {
506     CTimer::get("XIOS").resume();
507     bool isDefined = field_hdl->level.hasInheritedValue();
508     CTimer::get("XIOS").suspend();
509     return isDefined;
510  }
511
512
513  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
514  {
515    std::string long_name_str;
516    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
517    CTimer::get("XIOS").resume();
518    field_hdl->long_name.setValue(long_name_str);
519    CTimer::get("XIOS").suspend();
520  }
521
522  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
523  {
524    CTimer::get("XIOS").resume();
525    if (!string_copy(field_hdl->long_name.getInheritedValue(), long_name, long_name_size))
526      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", << "Input string is too short");
527    CTimer::get("XIOS").suspend();
528  }
529
530  bool cxios_is_defined_field_long_name(field_Ptr field_hdl)
531  {
532     CTimer::get("XIOS").resume();
533     bool isDefined = field_hdl->long_name.hasInheritedValue();
534     CTimer::get("XIOS").suspend();
535     return isDefined;
536  }
537
538
539  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
540  {
541    std::string name_str;
542    if (!cstr2string(name, name_size, name_str)) return;
543    CTimer::get("XIOS").resume();
544    field_hdl->name.setValue(name_str);
545    CTimer::get("XIOS").suspend();
546  }
547
548  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
549  {
550    CTimer::get("XIOS").resume();
551    if (!string_copy(field_hdl->name.getInheritedValue(), name, name_size))
552      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", << "Input string is too short");
553    CTimer::get("XIOS").suspend();
554  }
555
556  bool cxios_is_defined_field_name(field_Ptr field_hdl)
557  {
558     CTimer::get("XIOS").resume();
559     bool isDefined = field_hdl->name.hasInheritedValue();
560     CTimer::get("XIOS").suspend();
561     return isDefined;
562  }
563
564
565  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
566  {
567    std::string operation_str;
568    if (!cstr2string(operation, operation_size, operation_str)) return;
569    CTimer::get("XIOS").resume();
570    field_hdl->operation.setValue(operation_str);
571    CTimer::get("XIOS").suspend();
572  }
573
574  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
575  {
576    CTimer::get("XIOS").resume();
577    if (!string_copy(field_hdl->operation.getInheritedValue(), operation, operation_size))
578      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", << "Input string is too short");
579    CTimer::get("XIOS").suspend();
580  }
581
582  bool cxios_is_defined_field_operation(field_Ptr field_hdl)
583  {
584     CTimer::get("XIOS").resume();
585     bool isDefined = field_hdl->operation.hasInheritedValue();
586     CTimer::get("XIOS").suspend();
587     return isDefined;
588  }
589
590
591  void cxios_set_field_prec(field_Ptr field_hdl, int prec)
592  {
593    CTimer::get("XIOS").resume();
594    field_hdl->prec.setValue(prec);
595    CTimer::get("XIOS").suspend();
596  }
597
598  void cxios_get_field_prec(field_Ptr field_hdl, int* prec)
599  {
600    CTimer::get("XIOS").resume();
601    *prec = field_hdl->prec.getInheritedValue();
602    CTimer::get("XIOS").suspend();
603  }
604
605  bool cxios_is_defined_field_prec(field_Ptr field_hdl)
606  {
607     CTimer::get("XIOS").resume();
608     bool isDefined = field_hdl->prec.hasInheritedValue();
609     CTimer::get("XIOS").suspend();
610     return isDefined;
611  }
612
613
614  void cxios_set_field_read_access(field_Ptr field_hdl, bool read_access)
615  {
616    CTimer::get("XIOS").resume();
617    field_hdl->read_access.setValue(read_access);
618    CTimer::get("XIOS").suspend();
619  }
620
621  void cxios_get_field_read_access(field_Ptr field_hdl, bool* read_access)
622  {
623    CTimer::get("XIOS").resume();
624    *read_access = field_hdl->read_access.getInheritedValue();
625    CTimer::get("XIOS").suspend();
626  }
627
628  bool cxios_is_defined_field_read_access(field_Ptr field_hdl)
629  {
630     CTimer::get("XIOS").resume();
631     bool isDefined = field_hdl->read_access.hasInheritedValue();
632     CTimer::get("XIOS").suspend();
633     return isDefined;
634  }
635
636
637  void cxios_set_field_scalar_ref(field_Ptr field_hdl, const char * scalar_ref, int scalar_ref_size)
638  {
639    std::string scalar_ref_str;
640    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
641    CTimer::get("XIOS").resume();
642    field_hdl->scalar_ref.setValue(scalar_ref_str);
643    CTimer::get("XIOS").suspend();
644  }
645
646  void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size)
647  {
648    CTimer::get("XIOS").resume();
649    if (!string_copy(field_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
650      ERROR("void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
651    CTimer::get("XIOS").suspend();
652  }
653
654  bool cxios_is_defined_field_scalar_ref(field_Ptr field_hdl)
655  {
656     CTimer::get("XIOS").resume();
657     bool isDefined = field_hdl->scalar_ref.hasInheritedValue();
658     CTimer::get("XIOS").suspend();
659     return isDefined;
660  }
661
662
663  void cxios_set_field_scale_factor(field_Ptr field_hdl, double scale_factor)
664  {
665    CTimer::get("XIOS").resume();
666    field_hdl->scale_factor.setValue(scale_factor);
667    CTimer::get("XIOS").suspend();
668  }
669
670  void cxios_get_field_scale_factor(field_Ptr field_hdl, double* scale_factor)
671  {
672    CTimer::get("XIOS").resume();
673    *scale_factor = field_hdl->scale_factor.getInheritedValue();
674    CTimer::get("XIOS").suspend();
675  }
676
677  bool cxios_is_defined_field_scale_factor(field_Ptr field_hdl)
678  {
679     CTimer::get("XIOS").resume();
680     bool isDefined = field_hdl->scale_factor.hasInheritedValue();
681     CTimer::get("XIOS").suspend();
682     return isDefined;
683  }
684
685
686  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
687  {
688    std::string standard_name_str;
689    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
690    CTimer::get("XIOS").resume();
691    field_hdl->standard_name.setValue(standard_name_str);
692    CTimer::get("XIOS").suspend();
693  }
694
695  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
696  {
697    CTimer::get("XIOS").resume();
698    if (!string_copy(field_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
699      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
700    CTimer::get("XIOS").suspend();
701  }
702
703  bool cxios_is_defined_field_standard_name(field_Ptr field_hdl)
704  {
705     CTimer::get("XIOS").resume();
706     bool isDefined = field_hdl->standard_name.hasInheritedValue();
707     CTimer::get("XIOS").suspend();
708     return isDefined;
709  }
710
711
712  void cxios_set_field_ts_enabled(field_Ptr field_hdl, bool ts_enabled)
713  {
714    CTimer::get("XIOS").resume();
715    field_hdl->ts_enabled.setValue(ts_enabled);
716    CTimer::get("XIOS").suspend();
717  }
718
719  void cxios_get_field_ts_enabled(field_Ptr field_hdl, bool* ts_enabled)
720  {
721    CTimer::get("XIOS").resume();
722    *ts_enabled = field_hdl->ts_enabled.getInheritedValue();
723    CTimer::get("XIOS").suspend();
724  }
725
726  bool cxios_is_defined_field_ts_enabled(field_Ptr field_hdl)
727  {
728     CTimer::get("XIOS").resume();
729     bool isDefined = field_hdl->ts_enabled.hasInheritedValue();
730     CTimer::get("XIOS").suspend();
731     return isDefined;
732  }
733
734
735  void cxios_set_field_ts_split_freq(field_Ptr field_hdl, cxios_duration ts_split_freq_c)
736  {
737    CTimer::get("XIOS").resume();
738    field_hdl->ts_split_freq.allocate();
739    CDuration& ts_split_freq = field_hdl->ts_split_freq.get();
740    ts_split_freq.year = ts_split_freq_c.year;
741    ts_split_freq.month = ts_split_freq_c.month;
742    ts_split_freq.day = ts_split_freq_c.day;
743    ts_split_freq.hour = ts_split_freq_c.hour;
744    ts_split_freq.minute = ts_split_freq_c.minute;
745    ts_split_freq.second = ts_split_freq_c.second;
746    ts_split_freq.timestep = ts_split_freq_c.timestep;
747    CTimer::get("XIOS").suspend();
748  }
749
750  void cxios_get_field_ts_split_freq(field_Ptr field_hdl, cxios_duration* ts_split_freq_c)
751  {
752    CTimer::get("XIOS").resume();
753    CDuration ts_split_freq = field_hdl->ts_split_freq.getInheritedValue();
754    ts_split_freq_c->year = ts_split_freq.year;
755    ts_split_freq_c->month = ts_split_freq.month;
756    ts_split_freq_c->day = ts_split_freq.day;
757    ts_split_freq_c->hour = ts_split_freq.hour;
758    ts_split_freq_c->minute = ts_split_freq.minute;
759    ts_split_freq_c->second = ts_split_freq.second;
760    ts_split_freq_c->timestep = ts_split_freq.timestep;
761    CTimer::get("XIOS").suspend();
762  }
763
764  bool cxios_is_defined_field_ts_split_freq(field_Ptr field_hdl)
765  {
766     CTimer::get("XIOS").resume();
767     bool isDefined = field_hdl->ts_split_freq.hasInheritedValue();
768     CTimer::get("XIOS").suspend();
769     return isDefined;
770  }
771
772
773  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
774  {
775    std::string unit_str;
776    if (!cstr2string(unit, unit_size, unit_str)) return;
777    CTimer::get("XIOS").resume();
778    field_hdl->unit.setValue(unit_str);
779    CTimer::get("XIOS").suspend();
780  }
781
782  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
783  {
784    CTimer::get("XIOS").resume();
785    if (!string_copy(field_hdl->unit.getInheritedValue(), unit, unit_size))
786      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", << "Input string is too short");
787    CTimer::get("XIOS").suspend();
788  }
789
790  bool cxios_is_defined_field_unit(field_Ptr field_hdl)
791  {
792     CTimer::get("XIOS").resume();
793     bool isDefined = field_hdl->unit.hasInheritedValue();
794     CTimer::get("XIOS").suspend();
795     return isDefined;
796  }
797
798
799  void cxios_set_field_valid_max(field_Ptr field_hdl, double valid_max)
800  {
801    CTimer::get("XIOS").resume();
802    field_hdl->valid_max.setValue(valid_max);
803    CTimer::get("XIOS").suspend();
804  }
805
806  void cxios_get_field_valid_max(field_Ptr field_hdl, double* valid_max)
807  {
808    CTimer::get("XIOS").resume();
809    *valid_max = field_hdl->valid_max.getInheritedValue();
810    CTimer::get("XIOS").suspend();
811  }
812
813  bool cxios_is_defined_field_valid_max(field_Ptr field_hdl)
814  {
815     CTimer::get("XIOS").resume();
816     bool isDefined = field_hdl->valid_max.hasInheritedValue();
817     CTimer::get("XIOS").suspend();
818     return isDefined;
819  }
820
821
822  void cxios_set_field_valid_min(field_Ptr field_hdl, double valid_min)
823  {
824    CTimer::get("XIOS").resume();
825    field_hdl->valid_min.setValue(valid_min);
826    CTimer::get("XIOS").suspend();
827  }
828
829  void cxios_get_field_valid_min(field_Ptr field_hdl, double* valid_min)
830  {
831    CTimer::get("XIOS").resume();
832    *valid_min = field_hdl->valid_min.getInheritedValue();
833    CTimer::get("XIOS").suspend();
834  }
835
836  bool cxios_is_defined_field_valid_min(field_Ptr field_hdl)
837  {
838     CTimer::get("XIOS").resume();
839     bool isDefined = field_hdl->valid_min.hasInheritedValue();
840     CTimer::get("XIOS").suspend();
841     return isDefined;
842  }
843}
Note: See TracBrowser for help on using the repository browser.