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

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

Major Update

  • redesign Type and attribute manipulation
  • add enumerate type and attribute
  • use blitz class array instead of boost class array

YM

  • Property svn:eol-style set to native
File size: 12.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_axis_ref(fieldgroup_Ptr fieldgroup_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    fieldgroup_hdl->axis_ref.setValue(axis_ref_str);
25    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref);
26     CTimer::get("XIOS").suspend();
27  }
28 
29  void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)
30  {
31     CTimer::get("XIOS").resume();
32    if(!string_copy(fieldgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
33      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
34     CTimer::get("XIOS").suspend();
35  }
36 
37 
38  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
39  {
40     CTimer::get("XIOS").resume();
41    fieldgroup_hdl->default_value.setValue(default_value);
42    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value);
43     CTimer::get("XIOS").suspend();
44  }
45 
46  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value)
47  {
48    *default_value = fieldgroup_hdl->default_value.getValue();
49  }
50 
51 
52  void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, const char * domain_ref, int domain_ref_size)
53  {
54    std::string domain_ref_str;
55    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
56     CTimer::get("XIOS").resume();
57    fieldgroup_hdl->domain_ref.setValue(domain_ref_str);
58    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref);
59     CTimer::get("XIOS").suspend();
60  }
61 
62  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)
63  {
64     CTimer::get("XIOS").resume();
65    if(!string_copy(fieldgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
66      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
67     CTimer::get("XIOS").suspend();
68  }
69 
70 
71  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
72  {
73     CTimer::get("XIOS").resume();
74    fieldgroup_hdl->enabled.setValue(enabled);
75    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled);
76     CTimer::get("XIOS").suspend();
77  }
78 
79  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled)
80  {
81    *enabled = fieldgroup_hdl->enabled.getValue();
82  }
83 
84 
85  void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, const char * field_ref, int field_ref_size)
86  {
87    std::string field_ref_str;
88    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
89     CTimer::get("XIOS").resume();
90    fieldgroup_hdl->field_ref.setValue(field_ref_str);
91    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref);
92     CTimer::get("XIOS").suspend();
93  }
94 
95  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)
96  {
97     CTimer::get("XIOS").resume();
98    if(!string_copy(fieldgroup_hdl->field_ref.getValue(),field_ref , field_ref_size))
99      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
100     CTimer::get("XIOS").suspend();
101  }
102 
103 
104  void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, const char * freq_offset, int freq_offset_size)
105  {
106    std::string freq_offset_str;
107    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
108     CTimer::get("XIOS").resume();
109    fieldgroup_hdl->freq_offset.setValue(freq_offset_str);
110    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_offset);
111     CTimer::get("XIOS").suspend();
112  }
113 
114  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)
115  {
116     CTimer::get("XIOS").resume();
117    if(!string_copy(fieldgroup_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
118      ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
119     CTimer::get("XIOS").suspend();
120  }
121 
122 
123  void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, const char * freq_op, int freq_op_size)
124  {
125    std::string freq_op_str;
126    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
127     CTimer::get("XIOS").resume();
128    fieldgroup_hdl->freq_op.setValue(freq_op_str);
129    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op);
130     CTimer::get("XIOS").suspend();
131  }
132 
133  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)
134  {
135     CTimer::get("XIOS").resume();
136    if(!string_copy(fieldgroup_hdl->freq_op.getValue(),freq_op , freq_op_size))
137      ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
138     CTimer::get("XIOS").suspend();
139  }
140 
141 
142  void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, const char * grid_ref, int grid_ref_size)
143  {
144    std::string grid_ref_str;
145    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
146     CTimer::get("XIOS").resume();
147    fieldgroup_hdl->grid_ref.setValue(grid_ref_str);
148    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref);
149     CTimer::get("XIOS").suspend();
150  }
151 
152  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)
153  {
154     CTimer::get("XIOS").resume();
155    if(!string_copy(fieldgroup_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
156      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
157     CTimer::get("XIOS").suspend();
158  }
159 
160 
161  void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size)
162  {
163    std::string group_ref_str;
164    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
165     CTimer::get("XIOS").resume();
166    fieldgroup_hdl->group_ref.setValue(group_ref_str);
167    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->group_ref);
168     CTimer::get("XIOS").suspend();
169  }
170 
171  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)
172  {
173     CTimer::get("XIOS").resume();
174    if(!string_copy(fieldgroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
175      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
176     CTimer::get("XIOS").suspend();
177  }
178 
179 
180  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
181  {
182     CTimer::get("XIOS").resume();
183    fieldgroup_hdl->level.setValue(level);
184    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level);
185     CTimer::get("XIOS").suspend();
186  }
187 
188  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level)
189  {
190    *level = fieldgroup_hdl->level.getValue();
191  }
192 
193 
194  void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size)
195  {
196    std::string long_name_str;
197    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
198     CTimer::get("XIOS").resume();
199    fieldgroup_hdl->long_name.setValue(long_name_str);
200    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name);
201     CTimer::get("XIOS").suspend();
202  }
203 
204  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)
205  {
206     CTimer::get("XIOS").resume();
207    if(!string_copy(fieldgroup_hdl->long_name.getValue(),long_name , long_name_size))
208      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
209     CTimer::get("XIOS").suspend();
210  }
211 
212 
213  void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size)
214  {
215    std::string name_str;
216    if(!cstr2string(name, name_size, name_str)) return;
217     CTimer::get("XIOS").resume();
218    fieldgroup_hdl->name.setValue(name_str);
219    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name);
220     CTimer::get("XIOS").suspend();
221  }
222 
223  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)
224  {
225     CTimer::get("XIOS").resume();
226    if(!string_copy(fieldgroup_hdl->name.getValue(),name , name_size))
227      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short");
228     CTimer::get("XIOS").suspend();
229  }
230 
231 
232  void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size)
233  {
234    std::string operation_str;
235    if(!cstr2string(operation, operation_size, operation_str)) return;
236     CTimer::get("XIOS").resume();
237    fieldgroup_hdl->operation.setValue(operation_str);
238    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation);
239     CTimer::get("XIOS").suspend();
240  }
241 
242  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)
243  {
244     CTimer::get("XIOS").resume();
245    if(!string_copy(fieldgroup_hdl->operation.getValue(),operation , operation_size))
246      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short");
247     CTimer::get("XIOS").suspend();
248  }
249 
250 
251  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
252  {
253     CTimer::get("XIOS").resume();
254    fieldgroup_hdl->prec.setValue(prec);
255    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec);
256     CTimer::get("XIOS").suspend();
257  }
258 
259  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec)
260  {
261    *prec = fieldgroup_hdl->prec.getValue();
262  }
263 
264 
265  void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size)
266  {
267    std::string standard_name_str;
268    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
269     CTimer::get("XIOS").resume();
270    fieldgroup_hdl->standard_name.setValue(standard_name_str);
271    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name);
272     CTimer::get("XIOS").suspend();
273  }
274 
275  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)
276  {
277     CTimer::get("XIOS").resume();
278    if(!string_copy(fieldgroup_hdl->standard_name.getValue(),standard_name , standard_name_size))
279      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
280     CTimer::get("XIOS").suspend();
281  }
282 
283 
284  void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size)
285  {
286    std::string unit_str;
287    if(!cstr2string(unit, unit_size, unit_str)) return;
288     CTimer::get("XIOS").resume();
289    fieldgroup_hdl->unit.setValue(unit_str);
290    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit);
291     CTimer::get("XIOS").suspend();
292  }
293 
294  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)
295  {
296     CTimer::get("XIOS").resume();
297    if(!string_copy(fieldgroup_hdl->unit.getValue(),unit , unit_size))
298      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
299     CTimer::get("XIOS").suspend();
300  }
301 
302 
303 
304}
Note: See TracBrowser for help on using the repository browser.