source: XIOS/trunk/src/interface/c_attr/icfield_attr.cpp @ 501

Last change on this file since 501 was 501, checked in by ymipsl, 7 years ago

Add licence copyright to all file ond directory src using the command :
svn propset -R copyright -F header_licence src

XIOS is now officialy under CeCILL licence

YM

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