source: XIOS/branchs/xios-1.0/src/interface/c_attr/icfieldgroup_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: 19.7 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    bool isDefined = fieldgroup_hdl->add_offset.hasInheritedValue();
36    CTimer::get("XIOS").suspend();
37    return isDefined;
38  }
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    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref);
49     CTimer::get("XIOS").suspend();
50  }
51 
52  void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)
53  {
54     CTimer::get("XIOS").resume();
55    if(!string_copy(fieldgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size))
56      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl )
61  {
62    CTimer::get("XIOS").resume();
63    bool isDefined = fieldgroup_hdl->axis_ref.hasInheritedValue();
64    CTimer::get("XIOS").suspend();
65    return isDefined;
66  }
67 
68 
69 
70  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
71  {
72     CTimer::get("XIOS").resume();
73    fieldgroup_hdl->default_value.setValue(default_value);
74    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value);
75     CTimer::get("XIOS").suspend();
76  }
77 
78  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value)
79  {
80    *default_value = fieldgroup_hdl->default_value.getInheritedValue();
81  }
82 
83  bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl )
84  {
85    CTimer::get("XIOS").resume();
86    bool isDefined = fieldgroup_hdl->default_value.hasInheritedValue();
87    CTimer::get("XIOS").suspend();
88    return isDefined;
89  }
90 
91 
92 
93  void cxios_set_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool detect_missing_value)
94  {
95     CTimer::get("XIOS").resume();
96    fieldgroup_hdl->detect_missing_value.setValue(detect_missing_value);
97    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->detect_missing_value);
98     CTimer::get("XIOS").suspend();
99  }
100 
101  void cxios_get_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl, bool* detect_missing_value)
102  {
103    *detect_missing_value = fieldgroup_hdl->detect_missing_value.getInheritedValue();
104  }
105 
106  bool cxios_is_defined_fieldgroup_detect_missing_value(fieldgroup_Ptr fieldgroup_hdl )
107  {
108    CTimer::get("XIOS").resume();
109    bool isDefined = fieldgroup_hdl->detect_missing_value.hasInheritedValue();
110    CTimer::get("XIOS").suspend();
111    return isDefined;
112  }
113 
114 
115 
116  void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->domain_ref.setValue(domain_ref_str);
122    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref);
123     CTimer::get("XIOS").suspend();
124  }
125 
126  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)
127  {
128     CTimer::get("XIOS").resume();
129    if(!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size))
130      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl )
135  {
136    CTimer::get("XIOS").resume();
137    bool isDefined = fieldgroup_hdl->domain_ref.hasInheritedValue();
138    CTimer::get("XIOS").suspend();
139    return isDefined;
140  }
141 
142 
143 
144  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
145  {
146     CTimer::get("XIOS").resume();
147    fieldgroup_hdl->enabled.setValue(enabled);
148    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled);
149     CTimer::get("XIOS").suspend();
150  }
151 
152  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled)
153  {
154    *enabled = fieldgroup_hdl->enabled.getInheritedValue();
155  }
156 
157  bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl )
158  {
159    CTimer::get("XIOS").resume();
160    bool isDefined = fieldgroup_hdl->enabled.hasInheritedValue();
161    CTimer::get("XIOS").suspend();
162    return isDefined;
163  }
164 
165 
166 
167  void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->field_ref.setValue(field_ref_str);
173    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref);
174     CTimer::get("XIOS").suspend();
175  }
176 
177  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)
178  {
179     CTimer::get("XIOS").resume();
180    if(!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size))
181      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl )
186  {
187    CTimer::get("XIOS").resume();
188    bool isDefined = fieldgroup_hdl->field_ref.hasInheritedValue();
189    CTimer::get("XIOS").suspend();
190    return isDefined;
191  }
192 
193 
194 
195  void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->freq_offset.setValue(freq_offset_str);
201    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_offset);
202     CTimer::get("XIOS").suspend();
203  }
204 
205  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)
206  {
207     CTimer::get("XIOS").resume();
208    if(!string_copy(fieldgroup_hdl->freq_offset.getInheritedValue(),freq_offset , freq_offset_size))
209      ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_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_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl )
214  {
215    CTimer::get("XIOS").resume();
216    bool isDefined = fieldgroup_hdl->freq_offset.hasInheritedValue();
217    CTimer::get("XIOS").suspend();
218    return isDefined;
219  }
220 
221 
222 
223  void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->freq_op.setValue(freq_op_str);
229    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op);
230     CTimer::get("XIOS").suspend();
231  }
232 
233  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)
234  {
235     CTimer::get("XIOS").resume();
236    if(!string_copy(fieldgroup_hdl->freq_op.getInheritedValue(),freq_op , freq_op_size))
237      ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_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_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl )
242  {
243    CTimer::get("XIOS").resume();
244    bool isDefined = fieldgroup_hdl->freq_op.hasInheritedValue();
245    CTimer::get("XIOS").suspend();
246    return isDefined;
247  }
248 
249 
250 
251  void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->grid_ref.setValue(grid_ref_str);
257    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref);
258     CTimer::get("XIOS").suspend();
259  }
260 
261  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)
262  {
263     CTimer::get("XIOS").resume();
264    if(!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size))
265      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_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_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl )
270  {
271    CTimer::get("XIOS").resume();
272    bool isDefined = fieldgroup_hdl->grid_ref.hasInheritedValue();
273    CTimer::get("XIOS").suspend();
274    return isDefined;
275  }
276 
277 
278 
279  void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size)
280  {
281    std::string group_ref_str;
282    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
283     CTimer::get("XIOS").resume();
284    fieldgroup_hdl->group_ref.setValue(group_ref_str);
285    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->group_ref);
286     CTimer::get("XIOS").suspend();
287  }
288 
289  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)
290  {
291     CTimer::get("XIOS").resume();
292    if(!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size))
293      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
294     CTimer::get("XIOS").suspend();
295  }
296 
297  bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl )
298  {
299    CTimer::get("XIOS").resume();
300    bool isDefined = fieldgroup_hdl->group_ref.hasInheritedValue();
301    CTimer::get("XIOS").suspend();
302    return isDefined;
303  }
304 
305 
306 
307  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
308  {
309     CTimer::get("XIOS").resume();
310    fieldgroup_hdl->level.setValue(level);
311    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level);
312     CTimer::get("XIOS").suspend();
313  }
314 
315  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level)
316  {
317    *level = fieldgroup_hdl->level.getInheritedValue();
318  }
319 
320  bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl )
321  {
322    CTimer::get("XIOS").resume();
323    bool isDefined = fieldgroup_hdl->level.hasInheritedValue();
324    CTimer::get("XIOS").suspend();
325    return isDefined;
326  }
327 
328 
329 
330  void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size)
331  {
332    std::string long_name_str;
333    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
334     CTimer::get("XIOS").resume();
335    fieldgroup_hdl->long_name.setValue(long_name_str);
336    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name);
337     CTimer::get("XIOS").suspend();
338  }
339 
340  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)
341  {
342     CTimer::get("XIOS").resume();
343    if(!string_copy(fieldgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size))
344      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
345     CTimer::get("XIOS").suspend();
346  }
347 
348  bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl )
349  {
350    CTimer::get("XIOS").resume();
351    bool isDefined = fieldgroup_hdl->long_name.hasInheritedValue();
352    CTimer::get("XIOS").suspend();
353    return isDefined;
354  }
355 
356 
357 
358  void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size)
359  {
360    std::string name_str;
361    if(!cstr2string(name, name_size, name_str)) return;
362     CTimer::get("XIOS").resume();
363    fieldgroup_hdl->name.setValue(name_str);
364    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name);
365     CTimer::get("XIOS").suspend();
366  }
367 
368  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)
369  {
370     CTimer::get("XIOS").resume();
371    if(!string_copy(fieldgroup_hdl->name.getInheritedValue(),name , name_size))
372      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short");
373     CTimer::get("XIOS").suspend();
374  }
375 
376  bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl )
377  {
378    CTimer::get("XIOS").resume();
379    bool isDefined = fieldgroup_hdl->name.hasInheritedValue();
380    CTimer::get("XIOS").suspend();
381    return isDefined;
382  }
383 
384 
385 
386  void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size)
387  {
388    std::string operation_str;
389    if(!cstr2string(operation, operation_size, operation_str)) return;
390     CTimer::get("XIOS").resume();
391    fieldgroup_hdl->operation.setValue(operation_str);
392    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation);
393     CTimer::get("XIOS").suspend();
394  }
395 
396  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)
397  {
398     CTimer::get("XIOS").resume();
399    if(!string_copy(fieldgroup_hdl->operation.getInheritedValue(),operation , operation_size))
400      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short");
401     CTimer::get("XIOS").suspend();
402  }
403 
404  bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl )
405  {
406    CTimer::get("XIOS").resume();
407    bool isDefined = fieldgroup_hdl->operation.hasInheritedValue();
408    CTimer::get("XIOS").suspend();
409    return isDefined;
410  }
411 
412 
413 
414  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
415  {
416     CTimer::get("XIOS").resume();
417    fieldgroup_hdl->prec.setValue(prec);
418    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec);
419     CTimer::get("XIOS").suspend();
420  }
421 
422  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec)
423  {
424    *prec = fieldgroup_hdl->prec.getInheritedValue();
425  }
426 
427  bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl )
428  {
429    CTimer::get("XIOS").resume();
430    bool isDefined = fieldgroup_hdl->prec.hasInheritedValue();
431    CTimer::get("XIOS").suspend();
432    return isDefined;
433  }
434 
435 
436 
437  void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor)
438  {
439     CTimer::get("XIOS").resume();
440    fieldgroup_hdl->scale_factor.setValue(scale_factor);
441    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->scale_factor);
442     CTimer::get("XIOS").suspend();
443  }
444 
445  void cxios_get_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double* scale_factor)
446  {
447    *scale_factor = fieldgroup_hdl->scale_factor.getInheritedValue();
448  }
449 
450  bool cxios_is_defined_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl )
451  {
452    CTimer::get("XIOS").resume();
453    bool isDefined = fieldgroup_hdl->scale_factor.hasInheritedValue();
454    CTimer::get("XIOS").suspend();
455    return isDefined;
456  }
457 
458 
459 
460  void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size)
461  {
462    std::string standard_name_str;
463    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
464     CTimer::get("XIOS").resume();
465    fieldgroup_hdl->standard_name.setValue(standard_name_str);
466    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name);
467     CTimer::get("XIOS").suspend();
468  }
469 
470  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)
471  {
472     CTimer::get("XIOS").resume();
473    if(!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
474      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
475     CTimer::get("XIOS").suspend();
476  }
477 
478  bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl )
479  {
480    CTimer::get("XIOS").resume();
481    bool isDefined = fieldgroup_hdl->standard_name.hasInheritedValue();
482    CTimer::get("XIOS").suspend();
483    return isDefined;
484  }
485 
486 
487 
488  void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size)
489  {
490    std::string unit_str;
491    if(!cstr2string(unit, unit_size, unit_str)) return;
492     CTimer::get("XIOS").resume();
493    fieldgroup_hdl->unit.setValue(unit_str);
494    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit);
495     CTimer::get("XIOS").suspend();
496  }
497 
498  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)
499  {
500     CTimer::get("XIOS").resume();
501    if(!string_copy(fieldgroup_hdl->unit.getInheritedValue(),unit , unit_size))
502      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
503     CTimer::get("XIOS").suspend();
504  }
505 
506  bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl )
507  {
508    CTimer::get("XIOS").resume();
509    bool isDefined = fieldgroup_hdl->unit.hasInheritedValue();
510    CTimer::get("XIOS").suspend();
511    return isDefined;
512  }
513 
514 
515 
516  void cxios_set_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double valid_max)
517  {
518     CTimer::get("XIOS").resume();
519    fieldgroup_hdl->valid_max.setValue(valid_max);
520    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->valid_max);
521     CTimer::get("XIOS").suspend();
522  }
523 
524  void cxios_get_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl, double* valid_max)
525  {
526    *valid_max = fieldgroup_hdl->valid_max.getInheritedValue();
527  }
528 
529  bool cxios_is_defined_fieldgroup_valid_max(fieldgroup_Ptr fieldgroup_hdl )
530  {
531    CTimer::get("XIOS").resume();
532    bool isDefined = fieldgroup_hdl->valid_max.hasInheritedValue();
533    CTimer::get("XIOS").suspend();
534    return isDefined;
535  }
536 
537 
538 
539  void cxios_set_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double valid_min)
540  {
541     CTimer::get("XIOS").resume();
542    fieldgroup_hdl->valid_min.setValue(valid_min);
543    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->valid_min);
544     CTimer::get("XIOS").suspend();
545  }
546 
547  void cxios_get_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl, double* valid_min)
548  {
549    *valid_min = fieldgroup_hdl->valid_min.getInheritedValue();
550  }
551 
552  bool cxios_is_defined_fieldgroup_valid_min(fieldgroup_Ptr fieldgroup_hdl )
553  {
554    CTimer::get("XIOS").resume();
555    bool isDefined = fieldgroup_hdl->valid_min.hasInheritedValue();
556    CTimer::get("XIOS").suspend();
557    return isDefined;
558  }
559 
560 
561 
562 
563}
Note: See TracBrowser for help on using the repository browser.