source: XIOS/trunk/src/interface/c_attr/icfieldgroup_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: 19.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::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    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->add_offset);
24     CTimer::get("XIOS").suspend();
25  }
26 
27  void cxios_get_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl, double* add_offset)
28  {
29    *add_offset = fieldgroup_hdl->add_offset.getInheritedValue();
30  }
31 
32  bool cxios_is_defined_fieldgroup_add_offset(fieldgroup_Ptr fieldgroup_hdl )
33  {
34     CTimer::get("XIOS").resume();
35    return fieldgroup_hdl->add_offset.hasInheritedValue();
36     CTimer::get("XIOS").suspend();
37  }
38 
39 
40 
41  void cxios_set_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->axis_ref.setValue(axis_ref_str);
47    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref);
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 to 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    return fieldgroup_hdl->axis_ref.hasInheritedValue();
63     CTimer::get("XIOS").suspend();
64  }
65 
66 
67 
68  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
69  {
70     CTimer::get("XIOS").resume();
71    fieldgroup_hdl->default_value.setValue(default_value);
72    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value);
73     CTimer::get("XIOS").suspend();
74  }
75 
76  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value)
77  {
78    *default_value = fieldgroup_hdl->default_value.getInheritedValue();
79  }
80 
81  bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl )
82  {
83     CTimer::get("XIOS").resume();
84    return fieldgroup_hdl->default_value.hasInheritedValue();
85     CTimer::get("XIOS").suspend();
86  }
87 
88 
89 
90  void cxios_set_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool detect_missing_value)
91  {
92     CTimer::get("XIOS").resume();
93    fieldgroup_hdl->detect_missing_value.setValue(detect_missing_value);
94    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->detect_missing_value);
95     CTimer::get("XIOS").suspend();
96  }
97 
98  void cxios_get_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool* detect_missing_value)
99  {
100    *detect_missing_value = fieldgroup_hdl->detect_missing_value.getInheritedValue();
101  }
102 
103  bool cxios_is_defined_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl )
104  {
105     CTimer::get("XIOS").resume();
106    return fieldgroup_hdl->detect_missing_value.hasInheritedValue();
107     CTimer::get("XIOS").suspend();
108  }
109 
110 
111 
112  void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->domain_ref.setValue(domain_ref_str);
118    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref);
119     CTimer::get("XIOS").suspend();
120  }
121 
122  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)
123  {
124     CTimer::get("XIOS").resume();
125    if(!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size))
126      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl )
131  {
132     CTimer::get("XIOS").resume();
133    return fieldgroup_hdl->domain_ref.hasInheritedValue();
134     CTimer::get("XIOS").suspend();
135  }
136 
137 
138 
139  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
140  {
141     CTimer::get("XIOS").resume();
142    fieldgroup_hdl->enabled.setValue(enabled);
143    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled);
144     CTimer::get("XIOS").suspend();
145  }
146 
147  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled)
148  {
149    *enabled = fieldgroup_hdl->enabled.getInheritedValue();
150  }
151 
152  bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl )
153  {
154     CTimer::get("XIOS").resume();
155    return fieldgroup_hdl->enabled.hasInheritedValue();
156     CTimer::get("XIOS").suspend();
157  }
158 
159 
160 
161  void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->field_ref.setValue(field_ref_str);
167    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref);
168     CTimer::get("XIOS").suspend();
169  }
170 
171  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)
172  {
173     CTimer::get("XIOS").resume();
174    if(!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size))
175      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl )
180  {
181     CTimer::get("XIOS").resume();
182    return fieldgroup_hdl->field_ref.hasInheritedValue();
183     CTimer::get("XIOS").suspend();
184  }
185 
186 
187 
188  void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->freq_offset.setValue(freq_offset_str);
194    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_offset);
195     CTimer::get("XIOS").suspend();
196  }
197 
198  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)
199  {
200     CTimer::get("XIOS").resume();
201    if(!string_copy(fieldgroup_hdl->freq_offset.getInheritedValue(),freq_offset , freq_offset_size))
202      ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_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_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl )
207  {
208     CTimer::get("XIOS").resume();
209    return fieldgroup_hdl->freq_offset.hasInheritedValue();
210     CTimer::get("XIOS").suspend();
211  }
212 
213 
214 
215  void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->freq_op.setValue(freq_op_str);
221    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op);
222     CTimer::get("XIOS").suspend();
223  }
224 
225  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)
226  {
227     CTimer::get("XIOS").resume();
228    if(!string_copy(fieldgroup_hdl->freq_op.getInheritedValue(),freq_op , freq_op_size))
229      ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_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_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl )
234  {
235     CTimer::get("XIOS").resume();
236    return fieldgroup_hdl->freq_op.hasInheritedValue();
237     CTimer::get("XIOS").suspend();
238  }
239 
240 
241 
242  void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->grid_ref.setValue(grid_ref_str);
248    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref);
249     CTimer::get("XIOS").suspend();
250  }
251 
252  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)
253  {
254     CTimer::get("XIOS").resume();
255    if(!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size))
256      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl )
261  {
262     CTimer::get("XIOS").resume();
263    return fieldgroup_hdl->grid_ref.hasInheritedValue();
264     CTimer::get("XIOS").suspend();
265  }
266 
267 
268 
269  void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size)
270  {
271    std::string group_ref_str;
272    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
273     CTimer::get("XIOS").resume();
274    fieldgroup_hdl->group_ref.setValue(group_ref_str);
275    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->group_ref);
276     CTimer::get("XIOS").suspend();
277  }
278 
279  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)
280  {
281     CTimer::get("XIOS").resume();
282    if(!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size))
283      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
284     CTimer::get("XIOS").suspend();
285  }
286 
287  bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl )
288  {
289     CTimer::get("XIOS").resume();
290    return fieldgroup_hdl->group_ref.hasInheritedValue();
291     CTimer::get("XIOS").suspend();
292  }
293 
294 
295 
296  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
297  {
298     CTimer::get("XIOS").resume();
299    fieldgroup_hdl->level.setValue(level);
300    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level);
301     CTimer::get("XIOS").suspend();
302  }
303 
304  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level)
305  {
306    *level = fieldgroup_hdl->level.getInheritedValue();
307  }
308 
309  bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl )
310  {
311     CTimer::get("XIOS").resume();
312    return fieldgroup_hdl->level.hasInheritedValue();
313     CTimer::get("XIOS").suspend();
314  }
315 
316 
317 
318  void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size)
319  {
320    std::string long_name_str;
321    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
322     CTimer::get("XIOS").resume();
323    fieldgroup_hdl->long_name.setValue(long_name_str);
324    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name);
325     CTimer::get("XIOS").suspend();
326  }
327 
328  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)
329  {
330     CTimer::get("XIOS").resume();
331    if(!string_copy(fieldgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size))
332      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
333     CTimer::get("XIOS").suspend();
334  }
335 
336  bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl )
337  {
338     CTimer::get("XIOS").resume();
339    return fieldgroup_hdl->long_name.hasInheritedValue();
340     CTimer::get("XIOS").suspend();
341  }
342 
343 
344 
345  void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size)
346  {
347    std::string name_str;
348    if(!cstr2string(name, name_size, name_str)) return;
349     CTimer::get("XIOS").resume();
350    fieldgroup_hdl->name.setValue(name_str);
351    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name);
352     CTimer::get("XIOS").suspend();
353  }
354 
355  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)
356  {
357     CTimer::get("XIOS").resume();
358    if(!string_copy(fieldgroup_hdl->name.getInheritedValue(),name , name_size))
359      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short");
360     CTimer::get("XIOS").suspend();
361  }
362 
363  bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl )
364  {
365     CTimer::get("XIOS").resume();
366    return fieldgroup_hdl->name.hasInheritedValue();
367     CTimer::get("XIOS").suspend();
368  }
369 
370 
371 
372  void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size)
373  {
374    std::string operation_str;
375    if(!cstr2string(operation, operation_size, operation_str)) return;
376     CTimer::get("XIOS").resume();
377    fieldgroup_hdl->operation.setValue(operation_str);
378    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation);
379     CTimer::get("XIOS").suspend();
380  }
381 
382  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)
383  {
384     CTimer::get("XIOS").resume();
385    if(!string_copy(fieldgroup_hdl->operation.getInheritedValue(),operation , operation_size))
386      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short");
387     CTimer::get("XIOS").suspend();
388  }
389 
390  bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl )
391  {
392     CTimer::get("XIOS").resume();
393    return fieldgroup_hdl->operation.hasInheritedValue();
394     CTimer::get("XIOS").suspend();
395  }
396 
397 
398 
399  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
400  {
401     CTimer::get("XIOS").resume();
402    fieldgroup_hdl->prec.setValue(prec);
403    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec);
404     CTimer::get("XIOS").suspend();
405  }
406 
407  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec)
408  {
409    *prec = fieldgroup_hdl->prec.getInheritedValue();
410  }
411 
412  bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl )
413  {
414     CTimer::get("XIOS").resume();
415    return fieldgroup_hdl->prec.hasInheritedValue();
416     CTimer::get("XIOS").suspend();
417  }
418 
419 
420 
421  void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor)
422  {
423     CTimer::get("XIOS").resume();
424    fieldgroup_hdl->scale_factor.setValue(scale_factor);
425    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->scale_factor);
426     CTimer::get("XIOS").suspend();
427  }
428 
429  void cxios_get_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double* scale_factor)
430  {
431    *scale_factor = fieldgroup_hdl->scale_factor.getInheritedValue();
432  }
433 
434  bool cxios_is_defined_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl )
435  {
436     CTimer::get("XIOS").resume();
437    return fieldgroup_hdl->scale_factor.hasInheritedValue();
438     CTimer::get("XIOS").suspend();
439  }
440 
441 
442 
443  void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size)
444  {
445    std::string standard_name_str;
446    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
447     CTimer::get("XIOS").resume();
448    fieldgroup_hdl->standard_name.setValue(standard_name_str);
449    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name);
450     CTimer::get("XIOS").suspend();
451  }
452 
453  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)
454  {
455     CTimer::get("XIOS").resume();
456    if(!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
457      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
458     CTimer::get("XIOS").suspend();
459  }
460 
461  bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl )
462  {
463     CTimer::get("XIOS").resume();
464    return fieldgroup_hdl->standard_name.hasInheritedValue();
465     CTimer::get("XIOS").suspend();
466  }
467 
468 
469 
470  void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size)
471  {
472    std::string unit_str;
473    if(!cstr2string(unit, unit_size, unit_str)) return;
474     CTimer::get("XIOS").resume();
475    fieldgroup_hdl->unit.setValue(unit_str);
476    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit);
477     CTimer::get("XIOS").suspend();
478  }
479 
480  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)
481  {
482     CTimer::get("XIOS").resume();
483    if(!string_copy(fieldgroup_hdl->unit.getInheritedValue(),unit , unit_size))
484      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
485     CTimer::get("XIOS").suspend();
486  }
487 
488  bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl )
489  {
490     CTimer::get("XIOS").resume();
491    return fieldgroup_hdl->unit.hasInheritedValue();
492     CTimer::get("XIOS").suspend();
493  }
494 
495 
496 
497  void cxios_set_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double valid_max)
498  {
499     CTimer::get("XIOS").resume();
500    fieldgroup_hdl->valid_max.setValue(valid_max);
501    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->valid_max);
502     CTimer::get("XIOS").suspend();
503  }
504 
505  void cxios_get_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double* valid_max)
506  {
507    *valid_max = fieldgroup_hdl->valid_max.getInheritedValue();
508  }
509 
510  bool cxios_is_defined_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl )
511  {
512     CTimer::get("XIOS").resume();
513    return fieldgroup_hdl->valid_max.hasInheritedValue();
514     CTimer::get("XIOS").suspend();
515  }
516 
517 
518 
519  void cxios_set_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double valid_min)
520  {
521     CTimer::get("XIOS").resume();
522    fieldgroup_hdl->valid_min.setValue(valid_min);
523    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->valid_min);
524     CTimer::get("XIOS").suspend();
525  }
526 
527  void cxios_get_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double* valid_min)
528  {
529    *valid_min = fieldgroup_hdl->valid_min.getInheritedValue();
530  }
531 
532  bool cxios_is_defined_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl )
533  {
534     CTimer::get("XIOS").resume();
535    return fieldgroup_hdl->valid_min.hasInheritedValue();
536     CTimer::get("XIOS").suspend();
537  }
538 
539 
540 
541 
542}
Note: See TracBrowser for help on using the repository browser.