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