source: XIOS/branchs/xios-1.0/src/interface/c_attr/icfield_attr.cpp @ 581

Last change on this file since 581 was 581, checked in by rlacroix, 6 years ago

Fix the Fortran interface generation to avoid generating dead code that caused a timer not to be stopped.

  • 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: 17.0 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 "xmlioserver.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.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    field_hdl->sendAttributToServer(field_hdl->add_offset);
24     CTimer::get("XIOS").suspend();
25  }
26 
27  void cxios_get_field_add_offset(field_Ptr field_hdl, double* add_offset)
28  {
29    *add_offset = field_hdl->add_offset.getInheritedValue();
30  }
31 
32  bool cxios_is_defined_field_add_offset(field_Ptr field_hdl )
33  {
34    CTimer::get("XIOS").resume();
35    bool isDefined = field_hdl->add_offset.hasInheritedValue();
36    CTimer::get("XIOS").suspend();
37    return isDefined;
38  }
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    field_hdl->sendAttributToServer(field_hdl->axis_ref);
49     CTimer::get("XIOS").suspend();
50  }
51 
52  void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)
53  {
54     CTimer::get("XIOS").resume();
55    if(!string_copy(field_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size))
56      ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
57     CTimer::get("XIOS").suspend();
58  }
59 
60  bool cxios_is_defined_field_axis_ref(field_Ptr field_hdl )
61  {
62    CTimer::get("XIOS").resume();
63    bool isDefined = field_hdl->axis_ref.hasInheritedValue();
64    CTimer::get("XIOS").suspend();
65    return isDefined;
66  }
67 
68 
69 
70  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
71  {
72     CTimer::get("XIOS").resume();
73    field_hdl->default_value.setValue(default_value);
74    field_hdl->sendAttributToServer(field_hdl->default_value);
75     CTimer::get("XIOS").suspend();
76  }
77 
78  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value)
79  {
80    *default_value = field_hdl->default_value.getInheritedValue();
81  }
82 
83  bool cxios_is_defined_field_default_value(field_Ptr field_hdl )
84  {
85    CTimer::get("XIOS").resume();
86    bool isDefined = field_hdl->default_value.hasInheritedValue();
87    CTimer::get("XIOS").suspend();
88    return isDefined;
89  }
90 
91 
92 
93  void cxios_set_field_detect_missing_value(field_Ptr field_hdl, bool detect_missing_value)
94  {
95     CTimer::get("XIOS").resume();
96    field_hdl->detect_missing_value.setValue(detect_missing_value);
97    field_hdl->sendAttributToServer(field_hdl->detect_missing_value);
98     CTimer::get("XIOS").suspend();
99  }
100 
101  void cxios_get_field_detect_missing_value(field_Ptr field_hdl, bool* detect_missing_value)
102  {
103    *detect_missing_value = field_hdl->detect_missing_value.getInheritedValue();
104  }
105 
106  bool cxios_is_defined_field_detect_missing_value(field_Ptr field_hdl )
107  {
108    CTimer::get("XIOS").resume();
109    bool isDefined = field_hdl->detect_missing_value.hasInheritedValue();
110    CTimer::get("XIOS").suspend();
111    return isDefined;
112  }
113 
114 
115 
116  void cxios_set_field_domain_ref(field_Ptr field_hdl, const char * domain_ref, int domain_ref_size)
117  {
118    std::string domain_ref_str;
119    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
120     CTimer::get("XIOS").resume();
121    field_hdl->domain_ref.setValue(domain_ref_str);
122    field_hdl->sendAttributToServer(field_hdl->domain_ref);
123     CTimer::get("XIOS").suspend();
124  }
125 
126  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
127  {
128     CTimer::get("XIOS").resume();
129    if(!string_copy(field_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size))
130      ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
131     CTimer::get("XIOS").suspend();
132  }
133 
134  bool cxios_is_defined_field_domain_ref(field_Ptr field_hdl )
135  {
136    CTimer::get("XIOS").resume();
137    bool isDefined = field_hdl->domain_ref.hasInheritedValue();
138    CTimer::get("XIOS").suspend();
139    return isDefined;
140  }
141 
142 
143 
144  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
145  {
146     CTimer::get("XIOS").resume();
147    field_hdl->enabled.setValue(enabled);
148    field_hdl->sendAttributToServer(field_hdl->enabled);
149     CTimer::get("XIOS").suspend();
150  }
151 
152  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled)
153  {
154    *enabled = field_hdl->enabled.getInheritedValue();
155  }
156 
157  bool cxios_is_defined_field_enabled(field_Ptr field_hdl )
158  {
159    CTimer::get("XIOS").resume();
160    bool isDefined = field_hdl->enabled.hasInheritedValue();
161    CTimer::get("XIOS").suspend();
162    return isDefined;
163  }
164 
165 
166 
167  void cxios_set_field_field_ref(field_Ptr field_hdl, const char * field_ref, int field_ref_size)
168  {
169    std::string field_ref_str;
170    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
171     CTimer::get("XIOS").resume();
172    field_hdl->field_ref.setValue(field_ref_str);
173    field_hdl->sendAttributToServer(field_hdl->field_ref);
174     CTimer::get("XIOS").suspend();
175  }
176 
177  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
178  {
179     CTimer::get("XIOS").resume();
180    if(!string_copy(field_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size))
181      ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
182     CTimer::get("XIOS").suspend();
183  }
184 
185  bool cxios_is_defined_field_field_ref(field_Ptr field_hdl )
186  {
187    CTimer::get("XIOS").resume();
188    bool isDefined = field_hdl->field_ref.hasInheritedValue();
189    CTimer::get("XIOS").suspend();
190    return isDefined;
191  }
192 
193 
194 
195  void cxios_set_field_freq_offset(field_Ptr field_hdl, const char * freq_offset, int freq_offset_size)
196  {
197    std::string freq_offset_str;
198    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
199     CTimer::get("XIOS").resume();
200    field_hdl->freq_offset.setValue(freq_offset_str);
201    field_hdl->sendAttributToServer(field_hdl->freq_offset);
202     CTimer::get("XIOS").suspend();
203  }
204 
205  void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)
206  {
207     CTimer::get("XIOS").resume();
208    if(!string_copy(field_hdl->freq_offset.getInheritedValue(),freq_offset , freq_offset_size))
209      ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
210     CTimer::get("XIOS").suspend();
211  }
212 
213  bool cxios_is_defined_field_freq_offset(field_Ptr field_hdl )
214  {
215    CTimer::get("XIOS").resume();
216    bool isDefined = field_hdl->freq_offset.hasInheritedValue();
217    CTimer::get("XIOS").suspend();
218    return isDefined;
219  }
220 
221 
222 
223  void cxios_set_field_freq_op(field_Ptr field_hdl, const char * freq_op, int freq_op_size)
224  {
225    std::string freq_op_str;
226    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
227     CTimer::get("XIOS").resume();
228    field_hdl->freq_op.setValue(freq_op_str);
229    field_hdl->sendAttributToServer(field_hdl->freq_op);
230     CTimer::get("XIOS").suspend();
231  }
232 
233  void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)
234  {
235     CTimer::get("XIOS").resume();
236    if(!string_copy(field_hdl->freq_op.getInheritedValue(),freq_op , freq_op_size))
237      ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
238     CTimer::get("XIOS").suspend();
239  }
240 
241  bool cxios_is_defined_field_freq_op(field_Ptr field_hdl )
242  {
243    CTimer::get("XIOS").resume();
244    bool isDefined = field_hdl->freq_op.hasInheritedValue();
245    CTimer::get("XIOS").suspend();
246    return isDefined;
247  }
248 
249 
250 
251  void cxios_set_field_grid_ref(field_Ptr field_hdl, const char * grid_ref, int grid_ref_size)
252  {
253    std::string grid_ref_str;
254    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
255     CTimer::get("XIOS").resume();
256    field_hdl->grid_ref.setValue(grid_ref_str);
257    field_hdl->sendAttributToServer(field_hdl->grid_ref);
258     CTimer::get("XIOS").suspend();
259  }
260 
261  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
262  {
263     CTimer::get("XIOS").resume();
264    if(!string_copy(field_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size))
265      ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
266     CTimer::get("XIOS").suspend();
267  }
268 
269  bool cxios_is_defined_field_grid_ref(field_Ptr field_hdl )
270  {
271    CTimer::get("XIOS").resume();
272    bool isDefined = field_hdl->grid_ref.hasInheritedValue();
273    CTimer::get("XIOS").suspend();
274    return isDefined;
275  }
276 
277 
278 
279  void cxios_set_field_level(field_Ptr field_hdl, int level)
280  {
281     CTimer::get("XIOS").resume();
282    field_hdl->level.setValue(level);
283    field_hdl->sendAttributToServer(field_hdl->level);
284     CTimer::get("XIOS").suspend();
285  }
286 
287  void cxios_get_field_level(field_Ptr field_hdl, int* level)
288  {
289    *level = field_hdl->level.getInheritedValue();
290  }
291 
292  bool cxios_is_defined_field_level(field_Ptr field_hdl )
293  {
294    CTimer::get("XIOS").resume();
295    bool isDefined = field_hdl->level.hasInheritedValue();
296    CTimer::get("XIOS").suspend();
297    return isDefined;
298  }
299 
300 
301 
302  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
303  {
304    std::string long_name_str;
305    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
306     CTimer::get("XIOS").resume();
307    field_hdl->long_name.setValue(long_name_str);
308    field_hdl->sendAttributToServer(field_hdl->long_name);
309     CTimer::get("XIOS").suspend();
310  }
311 
312  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
313  {
314     CTimer::get("XIOS").resume();
315    if(!string_copy(field_hdl->long_name.getInheritedValue(),long_name , long_name_size))
316      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
317     CTimer::get("XIOS").suspend();
318  }
319 
320  bool cxios_is_defined_field_long_name(field_Ptr field_hdl )
321  {
322    CTimer::get("XIOS").resume();
323    bool isDefined = field_hdl->long_name.hasInheritedValue();
324    CTimer::get("XIOS").suspend();
325    return isDefined;
326  }
327 
328 
329 
330  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
331  {
332    std::string name_str;
333    if(!cstr2string(name, name_size, name_str)) return;
334     CTimer::get("XIOS").resume();
335    field_hdl->name.setValue(name_str);
336    field_hdl->sendAttributToServer(field_hdl->name);
337     CTimer::get("XIOS").suspend();
338  }
339 
340  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
341  {
342     CTimer::get("XIOS").resume();
343    if(!string_copy(field_hdl->name.getInheritedValue(),name , name_size))
344      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short");
345     CTimer::get("XIOS").suspend();
346  }
347 
348  bool cxios_is_defined_field_name(field_Ptr field_hdl )
349  {
350    CTimer::get("XIOS").resume();
351    bool isDefined = field_hdl->name.hasInheritedValue();
352    CTimer::get("XIOS").suspend();
353    return isDefined;
354  }
355 
356 
357 
358  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
359  {
360    std::string operation_str;
361    if(!cstr2string(operation, operation_size, operation_str)) return;
362     CTimer::get("XIOS").resume();
363    field_hdl->operation.setValue(operation_str);
364    field_hdl->sendAttributToServer(field_hdl->operation);
365     CTimer::get("XIOS").suspend();
366  }
367 
368  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
369  {
370     CTimer::get("XIOS").resume();
371    if(!string_copy(field_hdl->operation.getInheritedValue(),operation , operation_size))
372      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short");
373     CTimer::get("XIOS").suspend();
374  }
375 
376  bool cxios_is_defined_field_operation(field_Ptr field_hdl )
377  {
378    CTimer::get("XIOS").resume();
379    bool isDefined = field_hdl->operation.hasInheritedValue();
380    CTimer::get("XIOS").suspend();
381    return isDefined;
382  }
383 
384 
385 
386  void cxios_set_field_prec(field_Ptr field_hdl, int prec)
387  {
388     CTimer::get("XIOS").resume();
389    field_hdl->prec.setValue(prec);
390    field_hdl->sendAttributToServer(field_hdl->prec);
391     CTimer::get("XIOS").suspend();
392  }
393 
394  void cxios_get_field_prec(field_Ptr field_hdl, int* prec)
395  {
396    *prec = field_hdl->prec.getInheritedValue();
397  }
398 
399  bool cxios_is_defined_field_prec(field_Ptr field_hdl )
400  {
401    CTimer::get("XIOS").resume();
402    bool isDefined = field_hdl->prec.hasInheritedValue();
403    CTimer::get("XIOS").suspend();
404    return isDefined;
405  }
406 
407 
408 
409  void cxios_set_field_scale_factor(field_Ptr field_hdl, double scale_factor)
410  {
411     CTimer::get("XIOS").resume();
412    field_hdl->scale_factor.setValue(scale_factor);
413    field_hdl->sendAttributToServer(field_hdl->scale_factor);
414     CTimer::get("XIOS").suspend();
415  }
416 
417  void cxios_get_field_scale_factor(field_Ptr field_hdl, double* scale_factor)
418  {
419    *scale_factor = field_hdl->scale_factor.getInheritedValue();
420  }
421 
422  bool cxios_is_defined_field_scale_factor(field_Ptr field_hdl )
423  {
424    CTimer::get("XIOS").resume();
425    bool isDefined = field_hdl->scale_factor.hasInheritedValue();
426    CTimer::get("XIOS").suspend();
427    return isDefined;
428  }
429 
430 
431 
432  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
433  {
434    std::string standard_name_str;
435    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
436     CTimer::get("XIOS").resume();
437    field_hdl->standard_name.setValue(standard_name_str);
438    field_hdl->sendAttributToServer(field_hdl->standard_name);
439     CTimer::get("XIOS").suspend();
440  }
441 
442  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
443  {
444     CTimer::get("XIOS").resume();
445    if(!string_copy(field_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
446      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
447     CTimer::get("XIOS").suspend();
448  }
449 
450  bool cxios_is_defined_field_standard_name(field_Ptr field_hdl )
451  {
452    CTimer::get("XIOS").resume();
453    bool isDefined = field_hdl->standard_name.hasInheritedValue();
454    CTimer::get("XIOS").suspend();
455    return isDefined;
456  }
457 
458 
459 
460  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
461  {
462    std::string unit_str;
463    if(!cstr2string(unit, unit_size, unit_str)) return;
464     CTimer::get("XIOS").resume();
465    field_hdl->unit.setValue(unit_str);
466    field_hdl->sendAttributToServer(field_hdl->unit);
467     CTimer::get("XIOS").suspend();
468  }
469 
470  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
471  {
472     CTimer::get("XIOS").resume();
473    if(!string_copy(field_hdl->unit.getInheritedValue(),unit , unit_size))
474      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short");
475     CTimer::get("XIOS").suspend();
476  }
477 
478  bool cxios_is_defined_field_unit(field_Ptr field_hdl )
479  {
480    CTimer::get("XIOS").resume();
481    bool isDefined = field_hdl->unit.hasInheritedValue();
482    CTimer::get("XIOS").suspend();
483    return isDefined;
484  }
485 
486 
487 
488  void cxios_set_field_valid_max(field_Ptr field_hdl, double valid_max)
489  {
490     CTimer::get("XIOS").resume();
491    field_hdl->valid_max.setValue(valid_max);
492    field_hdl->sendAttributToServer(field_hdl->valid_max);
493     CTimer::get("XIOS").suspend();
494  }
495 
496  void cxios_get_field_valid_max(field_Ptr field_hdl, double* valid_max)
497  {
498    *valid_max = field_hdl->valid_max.getInheritedValue();
499  }
500 
501  bool cxios_is_defined_field_valid_max(field_Ptr field_hdl )
502  {
503    CTimer::get("XIOS").resume();
504    bool isDefined = field_hdl->valid_max.hasInheritedValue();
505    CTimer::get("XIOS").suspend();
506    return isDefined;
507  }
508 
509 
510 
511  void cxios_set_field_valid_min(field_Ptr field_hdl, double valid_min)
512  {
513     CTimer::get("XIOS").resume();
514    field_hdl->valid_min.setValue(valid_min);
515    field_hdl->sendAttributToServer(field_hdl->valid_min);
516     CTimer::get("XIOS").suspend();
517  }
518 
519  void cxios_get_field_valid_min(field_Ptr field_hdl, double* valid_min)
520  {
521    *valid_min = field_hdl->valid_min.getInheritedValue();
522  }
523 
524  bool cxios_is_defined_field_valid_min(field_Ptr field_hdl )
525  {
526    CTimer::get("XIOS").resume();
527    bool isDefined = field_hdl->valid_min.hasInheritedValue();
528    CTimer::get("XIOS").suspend();
529    return isDefined;
530  }
531 
532 
533 
534 
535}
Note: See TracBrowser for help on using the repository browser.