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

Last change on this file since 352 was 352, checked in by ymipsl, 10 years ago
  • Property svn:eol-style set to native
File size: 10.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 "field.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 
38  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
39  {
40     CTimer::get("XIOS").resume();
41    field_hdl->default_value.setValue(default_value);
42    field_hdl->sendAttributToServer(field_hdl->default_value);
43     CTimer::get("XIOS").suspend();
44  }
45 
46  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value)
47  {
48    *default_value = field_hdl->default_value.getValue();
49  }
50 
51 
52  void cxios_set_field_domain_ref(field_Ptr field_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    field_hdl->domain_ref.setValue(domain_ref_str);
58    field_hdl->sendAttributToServer(field_hdl->domain_ref);
59     CTimer::get("XIOS").suspend();
60  }
61 
62  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
63  {
64     CTimer::get("XIOS").resume();
65    if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
66      ERROR("void cxios_get_field_domain_ref(field_Ptr field_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_field_enabled(field_Ptr field_hdl, bool enabled)
72  {
73     CTimer::get("XIOS").resume();
74    field_hdl->enabled.setValue(enabled);
75    field_hdl->sendAttributToServer(field_hdl->enabled);
76     CTimer::get("XIOS").suspend();
77  }
78 
79  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled)
80  {
81    *enabled = field_hdl->enabled.getValue();
82  }
83 
84 
85  void cxios_set_field_field_ref(field_Ptr field_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    field_hdl->field_ref.setValue(field_ref_str);
91    field_hdl->sendAttributToServer(field_hdl->field_ref);
92     CTimer::get("XIOS").suspend();
93  }
94 
95  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
96  {
97     CTimer::get("XIOS").resume();
98    if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size))
99      ERROR("void cxios_get_field_field_ref(field_Ptr field_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_field_freq_offset(field_Ptr field_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    field_hdl->freq_offset.setValue(freq_offset_str);
110    field_hdl->sendAttributToServer(field_hdl->freq_offset);
111     CTimer::get("XIOS").suspend();
112  }
113 
114  void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)
115  {
116     CTimer::get("XIOS").resume();
117    if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
118      ERROR("void cxios_get_field_freq_offset(field_Ptr field_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_field_freq_op(field_Ptr field_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    field_hdl->freq_op.setValue(freq_op_str);
129    field_hdl->sendAttributToServer(field_hdl->freq_op);
130     CTimer::get("XIOS").suspend();
131  }
132 
133  void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)
134  {
135     CTimer::get("XIOS").resume();
136    if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size))
137      ERROR("void cxios_get_field_freq_op(field_Ptr field_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_field_grid_ref(field_Ptr field_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    field_hdl->grid_ref.setValue(grid_ref_str);
148    field_hdl->sendAttributToServer(field_hdl->grid_ref);
149     CTimer::get("XIOS").suspend();
150  }
151 
152  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
153  {
154     CTimer::get("XIOS").resume();
155    if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
156      ERROR("void cxios_get_field_grid_ref(field_Ptr field_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_field_level(field_Ptr field_hdl, int level)
162  {
163     CTimer::get("XIOS").resume();
164    field_hdl->level.setValue(level);
165    field_hdl->sendAttributToServer(field_hdl->level);
166     CTimer::get("XIOS").suspend();
167  }
168 
169  void cxios_get_field_level(field_Ptr field_hdl, int* level)
170  {
171    *level = field_hdl->level.getValue();
172  }
173 
174 
175  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
176  {
177    std::string long_name_str;
178    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
179     CTimer::get("XIOS").resume();
180    field_hdl->long_name.setValue(long_name_str);
181    field_hdl->sendAttributToServer(field_hdl->long_name);
182     CTimer::get("XIOS").suspend();
183  }
184 
185  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
186  {
187     CTimer::get("XIOS").resume();
188    if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size))
189      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
190     CTimer::get("XIOS").suspend();
191  }
192 
193 
194  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
195  {
196    std::string name_str;
197    if(!cstr2string(name, name_size, name_str)) return;
198     CTimer::get("XIOS").resume();
199    field_hdl->name.setValue(name_str);
200    field_hdl->sendAttributToServer(field_hdl->name);
201     CTimer::get("XIOS").suspend();
202  }
203 
204  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
205  {
206     CTimer::get("XIOS").resume();
207    if(!string_copy(field_hdl->name.getValue(),name , name_size))
208      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short");
209     CTimer::get("XIOS").suspend();
210  }
211 
212 
213  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
214  {
215    std::string operation_str;
216    if(!cstr2string(operation, operation_size, operation_str)) return;
217     CTimer::get("XIOS").resume();
218    field_hdl->operation.setValue(operation_str);
219    field_hdl->sendAttributToServer(field_hdl->operation);
220     CTimer::get("XIOS").suspend();
221  }
222 
223  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
224  {
225     CTimer::get("XIOS").resume();
226    if(!string_copy(field_hdl->operation.getValue(),operation , operation_size))
227      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short");
228     CTimer::get("XIOS").suspend();
229  }
230 
231 
232  void cxios_set_field_prec(field_Ptr field_hdl, int prec)
233  {
234     CTimer::get("XIOS").resume();
235    field_hdl->prec.setValue(prec);
236    field_hdl->sendAttributToServer(field_hdl->prec);
237     CTimer::get("XIOS").suspend();
238  }
239 
240  void cxios_get_field_prec(field_Ptr field_hdl, int* prec)
241  {
242    *prec = field_hdl->prec.getValue();
243  }
244 
245 
246  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
247  {
248    std::string standard_name_str;
249    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
250     CTimer::get("XIOS").resume();
251    field_hdl->standard_name.setValue(standard_name_str);
252    field_hdl->sendAttributToServer(field_hdl->standard_name);
253     CTimer::get("XIOS").suspend();
254  }
255 
256  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
257  {
258     CTimer::get("XIOS").resume();
259    if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size))
260      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
261     CTimer::get("XIOS").suspend();
262  }
263 
264 
265  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
266  {
267    std::string unit_str;
268    if(!cstr2string(unit, unit_size, unit_str)) return;
269     CTimer::get("XIOS").resume();
270    field_hdl->unit.setValue(unit_str);
271    field_hdl->sendAttributToServer(field_hdl->unit);
272     CTimer::get("XIOS").suspend();
273  }
274 
275  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
276  {
277     CTimer::get("XIOS").resume();
278    if(!string_copy(field_hdl->unit.getValue(),unit , unit_size))
279      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short");
280     CTimer::get("XIOS").suspend();
281  }
282 
283 
284 
285}
Note: See TracBrowser for help on using the repository browser.