source: XIOS/dev/dev_olga/src/interface/c_attr/icscalar_attr.cpp @ 1636

Last change on this file since 1636 was 1636, checked in by oabramkina, 5 years ago

Backporting r1626 to dev before merging it to trunk.

File size: 11.8 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                     *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include "xios.hpp"
7#include "attribute_template.hpp"
8#include "object_template.hpp"
9#include "group_template.hpp"
10#include "icutil.hpp"
11#include "icdate.hpp"
12#include "timer.hpp"
13#include "node_type.hpp"
14
15extern "C"
16{
17  typedef xios::CScalar* scalar_Ptr;
18
19  void cxios_set_scalar_axis_type(scalar_Ptr scalar_hdl, const char * axis_type, int axis_type_size)
20  {
21    std::string axis_type_str;
22    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return;
23    CTimer::get("XIOS").resume();
24    scalar_hdl->axis_type.fromString(axis_type_str);
25    CTimer::get("XIOS").suspend();
26  }
27
28  void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)
29  {
30    CTimer::get("XIOS").resume();
31    if (!string_copy(scalar_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size))
32      ERROR("void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)", << "Input string is too short");
33    CTimer::get("XIOS").suspend();
34  }
35
36  bool cxios_is_defined_scalar_axis_type(scalar_Ptr scalar_hdl)
37  {
38     CTimer::get("XIOS").resume();
39     bool isDefined = scalar_hdl->axis_type.hasInheritedValue();
40     CTimer::get("XIOS").suspend();
41     return isDefined;
42  }
43
44
45  void cxios_set_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent)
46  {
47    CTimer::get("XIOS").resume();
48    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
49    scalar_hdl->bounds.reference(tmp.copy());
50     CTimer::get("XIOS").suspend();
51  }
52
53  void cxios_get_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent)
54  {
55    CTimer::get("XIOS").resume();
56    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
57    tmp=scalar_hdl->bounds.getInheritedValue();
58     CTimer::get("XIOS").suspend();
59  }
60
61  bool cxios_is_defined_scalar_bounds(scalar_Ptr scalar_hdl)
62  {
63     CTimer::get("XIOS").resume();
64     bool isDefined = scalar_hdl->bounds.hasInheritedValue();
65     CTimer::get("XIOS").suspend();
66     return isDefined;
67  }
68
69
70  void cxios_set_scalar_bounds_name(scalar_Ptr scalar_hdl, const char * bounds_name, int bounds_name_size)
71  {
72    std::string bounds_name_str;
73    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return;
74    CTimer::get("XIOS").resume();
75    scalar_hdl->bounds_name.setValue(bounds_name_str);
76    CTimer::get("XIOS").suspend();
77  }
78
79  void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)
80  {
81    CTimer::get("XIOS").resume();
82    if (!string_copy(scalar_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size))
83      ERROR("void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short");
84    CTimer::get("XIOS").suspend();
85  }
86
87  bool cxios_is_defined_scalar_bounds_name(scalar_Ptr scalar_hdl)
88  {
89     CTimer::get("XIOS").resume();
90     bool isDefined = scalar_hdl->bounds_name.hasInheritedValue();
91     CTimer::get("XIOS").suspend();
92     return isDefined;
93  }
94
95
96  void cxios_set_scalar_comment(scalar_Ptr scalar_hdl, const char * comment, int comment_size)
97  {
98    std::string comment_str;
99    if (!cstr2string(comment, comment_size, comment_str)) return;
100    CTimer::get("XIOS").resume();
101    scalar_hdl->comment.setValue(comment_str);
102    CTimer::get("XIOS").suspend();
103  }
104
105  void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)
106  {
107    CTimer::get("XIOS").resume();
108    if (!string_copy(scalar_hdl->comment.getInheritedValue(), comment, comment_size))
109      ERROR("void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)", << "Input string is too short");
110    CTimer::get("XIOS").suspend();
111  }
112
113  bool cxios_is_defined_scalar_comment(scalar_Ptr scalar_hdl)
114  {
115     CTimer::get("XIOS").resume();
116     bool isDefined = scalar_hdl->comment.hasInheritedValue();
117     CTimer::get("XIOS").suspend();
118     return isDefined;
119  }
120
121
122  void cxios_set_scalar_label(scalar_Ptr scalar_hdl, const char * label, int label_size)
123  {
124    std::string label_str;
125    if (!cstr2string(label, label_size, label_str)) return;
126    CTimer::get("XIOS").resume();
127    scalar_hdl->label.setValue(label_str);
128    CTimer::get("XIOS").suspend();
129  }
130
131  void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)
132  {
133    CTimer::get("XIOS").resume();
134    if (!string_copy(scalar_hdl->label.getInheritedValue(), label, label_size))
135      ERROR("void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)", << "Input string is too short");
136    CTimer::get("XIOS").suspend();
137  }
138
139  bool cxios_is_defined_scalar_label(scalar_Ptr scalar_hdl)
140  {
141     CTimer::get("XIOS").resume();
142     bool isDefined = scalar_hdl->label.hasInheritedValue();
143     CTimer::get("XIOS").suspend();
144     return isDefined;
145  }
146
147
148  void cxios_set_scalar_long_name(scalar_Ptr scalar_hdl, const char * long_name, int long_name_size)
149  {
150    std::string long_name_str;
151    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
152    CTimer::get("XIOS").resume();
153    scalar_hdl->long_name.setValue(long_name_str);
154    CTimer::get("XIOS").suspend();
155  }
156
157  void cxios_get_scalar_long_name(scalar_Ptr scalar_hdl, char * long_name, int long_name_size)
158  {
159    CTimer::get("XIOS").resume();
160    if (!string_copy(scalar_hdl->long_name.getInheritedValue(), long_name, long_name_size))
161      ERROR("void cxios_get_scalar_long_name(scalar_Ptr scalar_hdl, char * long_name, int long_name_size)", << "Input string is too short");
162    CTimer::get("XIOS").suspend();
163  }
164
165  bool cxios_is_defined_scalar_long_name(scalar_Ptr scalar_hdl)
166  {
167     CTimer::get("XIOS").resume();
168     bool isDefined = scalar_hdl->long_name.hasInheritedValue();
169     CTimer::get("XIOS").suspend();
170     return isDefined;
171  }
172
173
174  void cxios_set_scalar_name(scalar_Ptr scalar_hdl, const char * name, int name_size)
175  {
176    std::string name_str;
177    if (!cstr2string(name, name_size, name_str)) return;
178    CTimer::get("XIOS").resume();
179    scalar_hdl->name.setValue(name_str);
180    CTimer::get("XIOS").suspend();
181  }
182
183  void cxios_get_scalar_name(scalar_Ptr scalar_hdl, char * name, int name_size)
184  {
185    CTimer::get("XIOS").resume();
186    if (!string_copy(scalar_hdl->name.getInheritedValue(), name, name_size))
187      ERROR("void cxios_get_scalar_name(scalar_Ptr scalar_hdl, char * name, int name_size)", << "Input string is too short");
188    CTimer::get("XIOS").suspend();
189  }
190
191  bool cxios_is_defined_scalar_name(scalar_Ptr scalar_hdl)
192  {
193     CTimer::get("XIOS").resume();
194     bool isDefined = scalar_hdl->name.hasInheritedValue();
195     CTimer::get("XIOS").suspend();
196     return isDefined;
197  }
198
199
200  void cxios_set_scalar_positive(scalar_Ptr scalar_hdl, const char * positive, int positive_size)
201  {
202    std::string positive_str;
203    if (!cstr2string(positive, positive_size, positive_str)) return;
204    CTimer::get("XIOS").resume();
205    scalar_hdl->positive.fromString(positive_str);
206    CTimer::get("XIOS").suspend();
207  }
208
209  void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)
210  {
211    CTimer::get("XIOS").resume();
212    if (!string_copy(scalar_hdl->positive.getInheritedStringValue(), positive, positive_size))
213      ERROR("void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)", << "Input string is too short");
214    CTimer::get("XIOS").suspend();
215  }
216
217  bool cxios_is_defined_scalar_positive(scalar_Ptr scalar_hdl)
218  {
219     CTimer::get("XIOS").resume();
220     bool isDefined = scalar_hdl->positive.hasInheritedValue();
221     CTimer::get("XIOS").suspend();
222     return isDefined;
223  }
224
225
226  void cxios_set_scalar_prec(scalar_Ptr scalar_hdl, int prec)
227  {
228    CTimer::get("XIOS").resume();
229    scalar_hdl->prec.setValue(prec);
230    CTimer::get("XIOS").suspend();
231  }
232
233  void cxios_get_scalar_prec(scalar_Ptr scalar_hdl, int* prec)
234  {
235    CTimer::get("XIOS").resume();
236    *prec = scalar_hdl->prec.getInheritedValue();
237    CTimer::get("XIOS").suspend();
238  }
239
240  bool cxios_is_defined_scalar_prec(scalar_Ptr scalar_hdl)
241  {
242     CTimer::get("XIOS").resume();
243     bool isDefined = scalar_hdl->prec.hasInheritedValue();
244     CTimer::get("XIOS").suspend();
245     return isDefined;
246  }
247
248
249  void cxios_set_scalar_scalar_ref(scalar_Ptr scalar_hdl, const char * scalar_ref, int scalar_ref_size)
250  {
251    std::string scalar_ref_str;
252    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
253    CTimer::get("XIOS").resume();
254    scalar_hdl->scalar_ref.setValue(scalar_ref_str);
255    CTimer::get("XIOS").suspend();
256  }
257
258  void cxios_get_scalar_scalar_ref(scalar_Ptr scalar_hdl, char * scalar_ref, int scalar_ref_size)
259  {
260    CTimer::get("XIOS").resume();
261    if (!string_copy(scalar_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
262      ERROR("void cxios_get_scalar_scalar_ref(scalar_Ptr scalar_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
263    CTimer::get("XIOS").suspend();
264  }
265
266  bool cxios_is_defined_scalar_scalar_ref(scalar_Ptr scalar_hdl)
267  {
268     CTimer::get("XIOS").resume();
269     bool isDefined = scalar_hdl->scalar_ref.hasInheritedValue();
270     CTimer::get("XIOS").suspend();
271     return isDefined;
272  }
273
274
275  void cxios_set_scalar_standard_name(scalar_Ptr scalar_hdl, const char * standard_name, int standard_name_size)
276  {
277    std::string standard_name_str;
278    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
279    CTimer::get("XIOS").resume();
280    scalar_hdl->standard_name.setValue(standard_name_str);
281    CTimer::get("XIOS").suspend();
282  }
283
284  void cxios_get_scalar_standard_name(scalar_Ptr scalar_hdl, char * standard_name, int standard_name_size)
285  {
286    CTimer::get("XIOS").resume();
287    if (!string_copy(scalar_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
288      ERROR("void cxios_get_scalar_standard_name(scalar_Ptr scalar_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
289    CTimer::get("XIOS").suspend();
290  }
291
292  bool cxios_is_defined_scalar_standard_name(scalar_Ptr scalar_hdl)
293  {
294     CTimer::get("XIOS").resume();
295     bool isDefined = scalar_hdl->standard_name.hasInheritedValue();
296     CTimer::get("XIOS").suspend();
297     return isDefined;
298  }
299
300
301  void cxios_set_scalar_unit(scalar_Ptr scalar_hdl, const char * unit, int unit_size)
302  {
303    std::string unit_str;
304    if (!cstr2string(unit, unit_size, unit_str)) return;
305    CTimer::get("XIOS").resume();
306    scalar_hdl->unit.setValue(unit_str);
307    CTimer::get("XIOS").suspend();
308  }
309
310  void cxios_get_scalar_unit(scalar_Ptr scalar_hdl, char * unit, int unit_size)
311  {
312    CTimer::get("XIOS").resume();
313    if (!string_copy(scalar_hdl->unit.getInheritedValue(), unit, unit_size))
314      ERROR("void cxios_get_scalar_unit(scalar_Ptr scalar_hdl, char * unit, int unit_size)", << "Input string is too short");
315    CTimer::get("XIOS").suspend();
316  }
317
318  bool cxios_is_defined_scalar_unit(scalar_Ptr scalar_hdl)
319  {
320     CTimer::get("XIOS").resume();
321     bool isDefined = scalar_hdl->unit.hasInheritedValue();
322     CTimer::get("XIOS").suspend();
323     return isDefined;
324  }
325
326
327  void cxios_set_scalar_value(scalar_Ptr scalar_hdl, double value)
328  {
329    CTimer::get("XIOS").resume();
330    scalar_hdl->value.setValue(value);
331    CTimer::get("XIOS").suspend();
332  }
333
334  void cxios_get_scalar_value(scalar_Ptr scalar_hdl, double* value)
335  {
336    CTimer::get("XIOS").resume();
337    *value = scalar_hdl->value.getInheritedValue();
338    CTimer::get("XIOS").suspend();
339  }
340
341  bool cxios_is_defined_scalar_value(scalar_Ptr scalar_hdl)
342  {
343     CTimer::get("XIOS").resume();
344     bool isDefined = scalar_hdl->value.hasInheritedValue();
345     CTimer::get("XIOS").suspend();
346     return isDefined;
347  }
348}
Note: See TracBrowser for help on using the repository browser.