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

Last change on this file since 432 was 432, checked in by ymipsl, 9 years ago

Enhancement : Add fortran interface to know if an attribute is set or not
ex : CALL xios_is_defined_field_attr("field_A",enabled=ok)

YM

  • Property svn:eol-style set to native
File size: 13.1 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_axis_ref(field_Ptr field_hdl, const char * axis_ref, int axis_ref_size)
20  {
21    std::string axis_ref_str;
22    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
23     CTimer::get("XIOS").resume();
24    field_hdl->axis_ref.setValue(axis_ref_str);
25    field_hdl->sendAttributToServer(field_hdl->axis_ref);
26     CTimer::get("XIOS").suspend();
27  }
28 
29  void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)
30  {
31     CTimer::get("XIOS").resume();
32    if(!string_copy(field_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
33      ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
34     CTimer::get("XIOS").suspend();
35  }
36 
37  bool cxios_is_defined_field_axis_ref(field_Ptr field_hdl )
38  {
39     CTimer::get("XIOS").resume();
40    return !field_hdl->axis_ref.isEmpty();
41     CTimer::get("XIOS").suspend();
42  }
43 
44 
45 
46  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
47  {
48     CTimer::get("XIOS").resume();
49    field_hdl->default_value.setValue(default_value);
50    field_hdl->sendAttributToServer(field_hdl->default_value);
51     CTimer::get("XIOS").suspend();
52  }
53 
54  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value)
55  {
56    *default_value = field_hdl->default_value.getValue();
57  }
58 
59  bool cxios_is_defined_field_default_value(field_Ptr field_hdl )
60  {
61     CTimer::get("XIOS").resume();
62    return !field_hdl->default_value.isEmpty();
63     CTimer::get("XIOS").suspend();
64  }
65 
66 
67 
68  void cxios_set_field_domain_ref(field_Ptr field_hdl, const char * domain_ref, int domain_ref_size)
69  {
70    std::string domain_ref_str;
71    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
72     CTimer::get("XIOS").resume();
73    field_hdl->domain_ref.setValue(domain_ref_str);
74    field_hdl->sendAttributToServer(field_hdl->domain_ref);
75     CTimer::get("XIOS").suspend();
76  }
77 
78  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
79  {
80     CTimer::get("XIOS").resume();
81    if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
82      ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
83     CTimer::get("XIOS").suspend();
84  }
85 
86  bool cxios_is_defined_field_domain_ref(field_Ptr field_hdl )
87  {
88     CTimer::get("XIOS").resume();
89    return !field_hdl->domain_ref.isEmpty();
90     CTimer::get("XIOS").suspend();
91  }
92 
93 
94 
95  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
96  {
97     CTimer::get("XIOS").resume();
98    field_hdl->enabled.setValue(enabled);
99    field_hdl->sendAttributToServer(field_hdl->enabled);
100     CTimer::get("XIOS").suspend();
101  }
102 
103  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled)
104  {
105    *enabled = field_hdl->enabled.getValue();
106  }
107 
108  bool cxios_is_defined_field_enabled(field_Ptr field_hdl )
109  {
110     CTimer::get("XIOS").resume();
111    return !field_hdl->enabled.isEmpty();
112     CTimer::get("XIOS").suspend();
113  }
114 
115 
116 
117  void cxios_set_field_field_ref(field_Ptr field_hdl, const char * field_ref, int field_ref_size)
118  {
119    std::string field_ref_str;
120    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
121     CTimer::get("XIOS").resume();
122    field_hdl->field_ref.setValue(field_ref_str);
123    field_hdl->sendAttributToServer(field_hdl->field_ref);
124     CTimer::get("XIOS").suspend();
125  }
126 
127  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
128  {
129     CTimer::get("XIOS").resume();
130    if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size))
131      ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
132     CTimer::get("XIOS").suspend();
133  }
134 
135  bool cxios_is_defined_field_field_ref(field_Ptr field_hdl )
136  {
137     CTimer::get("XIOS").resume();
138    return !field_hdl->field_ref.isEmpty();
139     CTimer::get("XIOS").suspend();
140  }
141 
142 
143 
144  void cxios_set_field_freq_offset(field_Ptr field_hdl, const char * freq_offset, int freq_offset_size)
145  {
146    std::string freq_offset_str;
147    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
148     CTimer::get("XIOS").resume();
149    field_hdl->freq_offset.setValue(freq_offset_str);
150    field_hdl->sendAttributToServer(field_hdl->freq_offset);
151     CTimer::get("XIOS").suspend();
152  }
153 
154  void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)
155  {
156     CTimer::get("XIOS").resume();
157    if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
158      ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
159     CTimer::get("XIOS").suspend();
160  }
161 
162  bool cxios_is_defined_field_freq_offset(field_Ptr field_hdl )
163  {
164     CTimer::get("XIOS").resume();
165    return !field_hdl->freq_offset.isEmpty();
166     CTimer::get("XIOS").suspend();
167  }
168 
169 
170 
171  void cxios_set_field_freq_op(field_Ptr field_hdl, const char * freq_op, int freq_op_size)
172  {
173    std::string freq_op_str;
174    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
175     CTimer::get("XIOS").resume();
176    field_hdl->freq_op.setValue(freq_op_str);
177    field_hdl->sendAttributToServer(field_hdl->freq_op);
178     CTimer::get("XIOS").suspend();
179  }
180 
181  void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)
182  {
183     CTimer::get("XIOS").resume();
184    if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size))
185      ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
186     CTimer::get("XIOS").suspend();
187  }
188 
189  bool cxios_is_defined_field_freq_op(field_Ptr field_hdl )
190  {
191     CTimer::get("XIOS").resume();
192    return !field_hdl->freq_op.isEmpty();
193     CTimer::get("XIOS").suspend();
194  }
195 
196 
197 
198  void cxios_set_field_grid_ref(field_Ptr field_hdl, const char * grid_ref, int grid_ref_size)
199  {
200    std::string grid_ref_str;
201    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
202     CTimer::get("XIOS").resume();
203    field_hdl->grid_ref.setValue(grid_ref_str);
204    field_hdl->sendAttributToServer(field_hdl->grid_ref);
205     CTimer::get("XIOS").suspend();
206  }
207 
208  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
209  {
210     CTimer::get("XIOS").resume();
211    if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
212      ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
213     CTimer::get("XIOS").suspend();
214  }
215 
216  bool cxios_is_defined_field_grid_ref(field_Ptr field_hdl )
217  {
218     CTimer::get("XIOS").resume();
219    return !field_hdl->grid_ref.isEmpty();
220     CTimer::get("XIOS").suspend();
221  }
222 
223 
224 
225  void cxios_set_field_level(field_Ptr field_hdl, int level)
226  {
227     CTimer::get("XIOS").resume();
228    field_hdl->level.setValue(level);
229    field_hdl->sendAttributToServer(field_hdl->level);
230     CTimer::get("XIOS").suspend();
231  }
232 
233  void cxios_get_field_level(field_Ptr field_hdl, int* level)
234  {
235    *level = field_hdl->level.getValue();
236  }
237 
238  bool cxios_is_defined_field_level(field_Ptr field_hdl )
239  {
240     CTimer::get("XIOS").resume();
241    return !field_hdl->level.isEmpty();
242     CTimer::get("XIOS").suspend();
243  }
244 
245 
246 
247  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
248  {
249    std::string long_name_str;
250    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
251     CTimer::get("XIOS").resume();
252    field_hdl->long_name.setValue(long_name_str);
253    field_hdl->sendAttributToServer(field_hdl->long_name);
254     CTimer::get("XIOS").suspend();
255  }
256 
257  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
258  {
259     CTimer::get("XIOS").resume();
260    if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size))
261      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
262     CTimer::get("XIOS").suspend();
263  }
264 
265  bool cxios_is_defined_field_long_name(field_Ptr field_hdl )
266  {
267     CTimer::get("XIOS").resume();
268    return !field_hdl->long_name.isEmpty();
269     CTimer::get("XIOS").suspend();
270  }
271 
272 
273 
274  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
275  {
276    std::string name_str;
277    if(!cstr2string(name, name_size, name_str)) return;
278     CTimer::get("XIOS").resume();
279    field_hdl->name.setValue(name_str);
280    field_hdl->sendAttributToServer(field_hdl->name);
281     CTimer::get("XIOS").suspend();
282  }
283 
284  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
285  {
286     CTimer::get("XIOS").resume();
287    if(!string_copy(field_hdl->name.getValue(),name , name_size))
288      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short");
289     CTimer::get("XIOS").suspend();
290  }
291 
292  bool cxios_is_defined_field_name(field_Ptr field_hdl )
293  {
294     CTimer::get("XIOS").resume();
295    return !field_hdl->name.isEmpty();
296     CTimer::get("XIOS").suspend();
297  }
298 
299 
300 
301  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
302  {
303    std::string operation_str;
304    if(!cstr2string(operation, operation_size, operation_str)) return;
305     CTimer::get("XIOS").resume();
306    field_hdl->operation.setValue(operation_str);
307    field_hdl->sendAttributToServer(field_hdl->operation);
308     CTimer::get("XIOS").suspend();
309  }
310 
311  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
312  {
313     CTimer::get("XIOS").resume();
314    if(!string_copy(field_hdl->operation.getValue(),operation , operation_size))
315      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short");
316     CTimer::get("XIOS").suspend();
317  }
318 
319  bool cxios_is_defined_field_operation(field_Ptr field_hdl )
320  {
321     CTimer::get("XIOS").resume();
322    return !field_hdl->operation.isEmpty();
323     CTimer::get("XIOS").suspend();
324  }
325 
326 
327 
328  void cxios_set_field_prec(field_Ptr field_hdl, int prec)
329  {
330     CTimer::get("XIOS").resume();
331    field_hdl->prec.setValue(prec);
332    field_hdl->sendAttributToServer(field_hdl->prec);
333     CTimer::get("XIOS").suspend();
334  }
335 
336  void cxios_get_field_prec(field_Ptr field_hdl, int* prec)
337  {
338    *prec = field_hdl->prec.getValue();
339  }
340 
341  bool cxios_is_defined_field_prec(field_Ptr field_hdl )
342  {
343     CTimer::get("XIOS").resume();
344    return !field_hdl->prec.isEmpty();
345     CTimer::get("XIOS").suspend();
346  }
347 
348 
349 
350  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
351  {
352    std::string standard_name_str;
353    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
354     CTimer::get("XIOS").resume();
355    field_hdl->standard_name.setValue(standard_name_str);
356    field_hdl->sendAttributToServer(field_hdl->standard_name);
357     CTimer::get("XIOS").suspend();
358  }
359 
360  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
361  {
362     CTimer::get("XIOS").resume();
363    if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size))
364      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
365     CTimer::get("XIOS").suspend();
366  }
367 
368  bool cxios_is_defined_field_standard_name(field_Ptr field_hdl )
369  {
370     CTimer::get("XIOS").resume();
371    return !field_hdl->standard_name.isEmpty();
372     CTimer::get("XIOS").suspend();
373  }
374 
375 
376 
377  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
378  {
379    std::string unit_str;
380    if(!cstr2string(unit, unit_size, unit_str)) return;
381     CTimer::get("XIOS").resume();
382    field_hdl->unit.setValue(unit_str);
383    field_hdl->sendAttributToServer(field_hdl->unit);
384     CTimer::get("XIOS").suspend();
385  }
386 
387  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
388  {
389     CTimer::get("XIOS").resume();
390    if(!string_copy(field_hdl->unit.getValue(),unit , unit_size))
391      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short");
392     CTimer::get("XIOS").suspend();
393  }
394 
395  bool cxios_is_defined_field_unit(field_Ptr field_hdl )
396  {
397     CTimer::get("XIOS").resume();
398    return !field_hdl->unit.isEmpty();
399     CTimer::get("XIOS").suspend();
400  }
401 
402 
403 
404 
405}
Note: See TracBrowser for help on using the repository browser.