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

Last change on this file since 329 was 325, checked in by ymipsl, 10 years ago

port to gfortran/g++

YM

  • Property svn:eol-style set to native
File size: 8.5 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_impl.hpp"
9#include "object_template_impl.hpp"
10#include "group_template_impl.hpp"
11#include "icutil.hpp"
12
13extern "C"
14{
15  typedef xmlioserver::tree::CField*  field_Ptr;
16 
17  void cxios_set_field_axis_ref(field_Ptr field_hdl, const char * axis_ref, int axis_ref_size)
18  {
19    std::string axis_ref_str;
20    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
21    field_hdl->axis_ref.setValue(axis_ref_str);
22    field_hdl->sendAttributToServer(field_hdl->axis_ref);
23  }
24 
25  void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)
26  {
27    if(!string_copy(field_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
28      ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
29  }
30 
31 
32  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
33  {
34    field_hdl->default_value.setValue(default_value);
35    field_hdl->sendAttributToServer(field_hdl->default_value);
36  }
37 
38  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value)
39  {
40    *default_value = field_hdl->default_value.getValue();
41  }
42 
43 
44  void cxios_set_field_domain_ref(field_Ptr field_hdl, const char * domain_ref, int domain_ref_size)
45  {
46    std::string domain_ref_str;
47    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
48    field_hdl->domain_ref.setValue(domain_ref_str);
49    field_hdl->sendAttributToServer(field_hdl->domain_ref);
50  }
51 
52  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
53  {
54    if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
55      ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
56  }
57 
58 
59  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
60  {
61    field_hdl->enabled.setValue(enabled);
62    field_hdl->sendAttributToServer(field_hdl->enabled);
63  }
64 
65  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled)
66  {
67    *enabled = field_hdl->enabled.getValue();
68  }
69 
70 
71  void cxios_set_field_field_ref(field_Ptr field_hdl, const char * field_ref, int field_ref_size)
72  {
73    std::string field_ref_str;
74    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
75    field_hdl->field_ref.setValue(field_ref_str);
76    field_hdl->sendAttributToServer(field_hdl->field_ref);
77  }
78 
79  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
80  {
81    if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size))
82      ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
83  }
84 
85 
86  void cxios_set_field_freq_offset(field_Ptr field_hdl, const char * freq_offset, int freq_offset_size)
87  {
88    std::string freq_offset_str;
89    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
90    field_hdl->freq_offset.setValue(freq_offset_str);
91    field_hdl->sendAttributToServer(field_hdl->freq_offset);
92  }
93 
94  void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)
95  {
96    if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
97      ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
98  }
99 
100 
101  void cxios_set_field_freq_op(field_Ptr field_hdl, const char * freq_op, int freq_op_size)
102  {
103    std::string freq_op_str;
104    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
105    field_hdl->freq_op.setValue(freq_op_str);
106    field_hdl->sendAttributToServer(field_hdl->freq_op);
107  }
108 
109  void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)
110  {
111    if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size))
112      ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
113  }
114 
115 
116  void cxios_set_field_grid_ref(field_Ptr field_hdl, const char * grid_ref, int grid_ref_size)
117  {
118    std::string grid_ref_str;
119    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
120    field_hdl->grid_ref.setValue(grid_ref_str);
121    field_hdl->sendAttributToServer(field_hdl->grid_ref);
122  }
123 
124  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
125  {
126    if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
127      ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
128  }
129 
130 
131  void cxios_set_field_level(field_Ptr field_hdl, int level)
132  {
133    field_hdl->level.setValue(level);
134    field_hdl->sendAttributToServer(field_hdl->level);
135  }
136 
137  void cxios_get_field_level(field_Ptr field_hdl, int* level)
138  {
139    *level = field_hdl->level.getValue();
140  }
141 
142 
143  void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
144  {
145    std::string long_name_str;
146    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
147    field_hdl->long_name.setValue(long_name_str);
148    field_hdl->sendAttributToServer(field_hdl->long_name);
149  }
150 
151  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
152  {
153    if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size))
154      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
155  }
156 
157 
158  void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
159  {
160    std::string name_str;
161    if(!cstr2string(name, name_size, name_str)) return;
162    field_hdl->name.setValue(name_str);
163    field_hdl->sendAttributToServer(field_hdl->name);
164  }
165 
166  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
167  {
168    if(!string_copy(field_hdl->name.getValue(),name , name_size))
169      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short");
170  }
171 
172 
173  void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
174  {
175    std::string operation_str;
176    if(!cstr2string(operation, operation_size, operation_str)) return;
177    field_hdl->operation.setValue(operation_str);
178    field_hdl->sendAttributToServer(field_hdl->operation);
179  }
180 
181  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
182  {
183    if(!string_copy(field_hdl->operation.getValue(),operation , operation_size))
184      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short");
185  }
186 
187 
188  void cxios_set_field_prec(field_Ptr field_hdl, int prec)
189  {
190    field_hdl->prec.setValue(prec);
191    field_hdl->sendAttributToServer(field_hdl->prec);
192  }
193 
194  void cxios_get_field_prec(field_Ptr field_hdl, int* prec)
195  {
196    *prec = field_hdl->prec.getValue();
197  }
198 
199 
200  void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
201  {
202    std::string standard_name_str;
203    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
204    field_hdl->standard_name.setValue(standard_name_str);
205    field_hdl->sendAttributToServer(field_hdl->standard_name);
206  }
207 
208  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
209  {
210    if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size))
211      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
212  }
213 
214 
215  void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
216  {
217    std::string unit_str;
218    if(!cstr2string(unit, unit_size, unit_str)) return;
219    field_hdl->unit.setValue(unit_str);
220    field_hdl->sendAttributToServer(field_hdl->unit);
221  }
222 
223  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
224  {
225    if(!string_copy(field_hdl->unit.getValue(),unit , unit_size))
226      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short");
227  }
228 
229 
230 
231}
Note: See TracBrowser for help on using the repository browser.