source: XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp @ 509

Last change on this file since 509 was 509, checked in by mhnguyen, 7 years ago

Implementing buffer size auto-detection for mode client -server

+) Process xml tree in client side then send all the information to server
+) Only information enabled fields in enabled files are sent to server
+) Some important change in structure of code which must be refactored

Test
+) On Curie
+) Only mode client-server
+) Passed for all tests

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