source: XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp @ 674

Last change on this file since 674 was 674, checked in by rlacroix, 6 years ago

Fix Fortran interface generation to avoid generating long lines.

Long lines can cause compilation issues with some compilers.

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:eol-style set to native
File size: 11.7 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 "xios.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.hpp"
12#include "icdate.hpp"
13#include "timer.hpp"
14#include "node_type.hpp"
15
16extern "C"
17{
18  typedef xios::CAxis* axis_Ptr;
19
20  void cxios_set_axis_axis_ref(axis_Ptr axis_hdl, const char * axis_ref, int axis_ref_size)
21  {
22    std::string axis_ref_str;
23    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
24    CTimer::get("XIOS").resume();
25    axis_hdl->axis_ref.setValue(axis_ref_str);
26    CTimer::get("XIOS").suspend();
27  }
28
29  void cxios_get_axis_axis_ref(axis_Ptr axis_hdl, char * axis_ref, int axis_ref_size)
30  {
31    CTimer::get("XIOS").resume();
32    if (!string_copy(axis_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size))
33      ERROR("void cxios_get_axis_axis_ref(axis_Ptr axis_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short");
34    CTimer::get("XIOS").suspend();
35  }
36
37  bool cxios_is_defined_axis_axis_ref(axis_Ptr axis_hdl)
38  {
39     CTimer::get("XIOS").resume();
40     bool isDefined = axis_hdl->axis_ref.hasInheritedValue();
41     CTimer::get("XIOS").suspend();
42     return isDefined;
43  }
44
45
46  void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin)
47  {
48    CTimer::get("XIOS").resume();
49    axis_hdl->begin.setValue(begin);
50    CTimer::get("XIOS").suspend();
51  }
52
53  void cxios_get_axis_begin(axis_Ptr axis_hdl, int* begin)
54  {
55    CTimer::get("XIOS").resume();
56    *begin = axis_hdl->begin.getInheritedValue();
57    CTimer::get("XIOS").suspend();
58  }
59
60  bool cxios_is_defined_axis_begin(axis_Ptr axis_hdl)
61  {
62     CTimer::get("XIOS").resume();
63     bool isDefined = axis_hdl->begin.hasInheritedValue();
64     CTimer::get("XIOS").suspend();
65     return isDefined;
66  }
67
68
69  void cxios_set_axis_bounds(axis_Ptr axis_hdl, double* bounds, int* extent)
70  {
71    CTimer::get("XIOS").resume();
72    CArray<double,2> tmp(bounds, shape(extent[0], extent[1]), neverDeleteData);
73    axis_hdl->bounds.reference(tmp.copy());
74     CTimer::get("XIOS").suspend();
75  }
76
77  void cxios_get_axis_bounds(axis_Ptr axis_hdl, double* bounds, int* extent)
78  {
79    CTimer::get("XIOS").resume();
80    CArray<double,2> tmp(bounds, shape(extent[0], extent[1]), neverDeleteData);
81    tmp=axis_hdl->bounds.getInheritedValue();
82     CTimer::get("XIOS").suspend();
83  }
84
85  bool cxios_is_defined_axis_bounds(axis_Ptr axis_hdl)
86  {
87     CTimer::get("XIOS").resume();
88     bool isDefined = axis_hdl->bounds.hasInheritedValue();
89     CTimer::get("XIOS").suspend();
90     return isDefined;
91  }
92
93
94  void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin)
95  {
96    CTimer::get("XIOS").resume();
97    axis_hdl->data_begin.setValue(data_begin);
98    CTimer::get("XIOS").suspend();
99  }
100
101  void cxios_get_axis_data_begin(axis_Ptr axis_hdl, int* data_begin)
102  {
103    CTimer::get("XIOS").resume();
104    *data_begin = axis_hdl->data_begin.getInheritedValue();
105    CTimer::get("XIOS").suspend();
106  }
107
108  bool cxios_is_defined_axis_data_begin(axis_Ptr axis_hdl)
109  {
110     CTimer::get("XIOS").resume();
111     bool isDefined = axis_hdl->data_begin.hasInheritedValue();
112     CTimer::get("XIOS").suspend();
113     return isDefined;
114  }
115
116
117  void cxios_set_axis_data_index(axis_Ptr axis_hdl, int* data_index, int* extent)
118  {
119    CTimer::get("XIOS").resume();
120    CArray<int,1> tmp(data_index, shape(extent[0]), neverDeleteData);
121    axis_hdl->data_index.reference(tmp.copy());
122     CTimer::get("XIOS").suspend();
123  }
124
125  void cxios_get_axis_data_index(axis_Ptr axis_hdl, int* data_index, int* extent)
126  {
127    CTimer::get("XIOS").resume();
128    CArray<int,1> tmp(data_index, shape(extent[0]), neverDeleteData);
129    tmp=axis_hdl->data_index.getInheritedValue();
130     CTimer::get("XIOS").suspend();
131  }
132
133  bool cxios_is_defined_axis_data_index(axis_Ptr axis_hdl)
134  {
135     CTimer::get("XIOS").resume();
136     bool isDefined = axis_hdl->data_index.hasInheritedValue();
137     CTimer::get("XIOS").suspend();
138     return isDefined;
139  }
140
141
142  void cxios_set_axis_data_n(axis_Ptr axis_hdl, int data_n)
143  {
144    CTimer::get("XIOS").resume();
145    axis_hdl->data_n.setValue(data_n);
146    CTimer::get("XIOS").suspend();
147  }
148
149  void cxios_get_axis_data_n(axis_Ptr axis_hdl, int* data_n)
150  {
151    CTimer::get("XIOS").resume();
152    *data_n = axis_hdl->data_n.getInheritedValue();
153    CTimer::get("XIOS").suspend();
154  }
155
156  bool cxios_is_defined_axis_data_n(axis_Ptr axis_hdl)
157  {
158     CTimer::get("XIOS").resume();
159     bool isDefined = axis_hdl->data_n.hasInheritedValue();
160     CTimer::get("XIOS").suspend();
161     return isDefined;
162  }
163
164
165  void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size)
166  {
167    std::string long_name_str;
168    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
169    CTimer::get("XIOS").resume();
170    axis_hdl->long_name.setValue(long_name_str);
171    CTimer::get("XIOS").suspend();
172  }
173
174  void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)
175  {
176    CTimer::get("XIOS").resume();
177    if (!string_copy(axis_hdl->long_name.getInheritedValue(), long_name, long_name_size))
178      ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", << "Input string is too short");
179    CTimer::get("XIOS").suspend();
180  }
181
182  bool cxios_is_defined_axis_long_name(axis_Ptr axis_hdl)
183  {
184     CTimer::get("XIOS").resume();
185     bool isDefined = axis_hdl->long_name.hasInheritedValue();
186     CTimer::get("XIOS").suspend();
187     return isDefined;
188  }
189
190
191  void cxios_set_axis_mask(axis_Ptr axis_hdl, bool* mask, int* extent)
192  {
193    CTimer::get("XIOS").resume();
194    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
195    axis_hdl->mask.reference(tmp.copy());
196     CTimer::get("XIOS").suspend();
197  }
198
199  void cxios_get_axis_mask(axis_Ptr axis_hdl, bool* mask, int* extent)
200  {
201    CTimer::get("XIOS").resume();
202    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
203    tmp=axis_hdl->mask.getInheritedValue();
204     CTimer::get("XIOS").suspend();
205  }
206
207  bool cxios_is_defined_axis_mask(axis_Ptr axis_hdl)
208  {
209     CTimer::get("XIOS").resume();
210     bool isDefined = axis_hdl->mask.hasInheritedValue();
211     CTimer::get("XIOS").suspend();
212     return isDefined;
213  }
214
215
216  void cxios_set_axis_n(axis_Ptr axis_hdl, int n)
217  {
218    CTimer::get("XIOS").resume();
219    axis_hdl->n.setValue(n);
220    CTimer::get("XIOS").suspend();
221  }
222
223  void cxios_get_axis_n(axis_Ptr axis_hdl, int* n)
224  {
225    CTimer::get("XIOS").resume();
226    *n = axis_hdl->n.getInheritedValue();
227    CTimer::get("XIOS").suspend();
228  }
229
230  bool cxios_is_defined_axis_n(axis_Ptr axis_hdl)
231  {
232     CTimer::get("XIOS").resume();
233     bool isDefined = axis_hdl->n.hasInheritedValue();
234     CTimer::get("XIOS").suspend();
235     return isDefined;
236  }
237
238
239  void cxios_set_axis_n_glo(axis_Ptr axis_hdl, int n_glo)
240  {
241    CTimer::get("XIOS").resume();
242    axis_hdl->n_glo.setValue(n_glo);
243    CTimer::get("XIOS").suspend();
244  }
245
246  void cxios_get_axis_n_glo(axis_Ptr axis_hdl, int* n_glo)
247  {
248    CTimer::get("XIOS").resume();
249    *n_glo = axis_hdl->n_glo.getInheritedValue();
250    CTimer::get("XIOS").suspend();
251  }
252
253  bool cxios_is_defined_axis_n_glo(axis_Ptr axis_hdl)
254  {
255     CTimer::get("XIOS").resume();
256     bool isDefined = axis_hdl->n_glo.hasInheritedValue();
257     CTimer::get("XIOS").suspend();
258     return isDefined;
259  }
260
261
262  void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size)
263  {
264    std::string name_str;
265    if (!cstr2string(name, name_size, name_str)) return;
266    CTimer::get("XIOS").resume();
267    axis_hdl->name.setValue(name_str);
268    CTimer::get("XIOS").suspend();
269  }
270
271  void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)
272  {
273    CTimer::get("XIOS").resume();
274    if (!string_copy(axis_hdl->name.getInheritedValue(), name, name_size))
275      ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", << "Input string is too short");
276    CTimer::get("XIOS").suspend();
277  }
278
279  bool cxios_is_defined_axis_name(axis_Ptr axis_hdl)
280  {
281     CTimer::get("XIOS").resume();
282     bool isDefined = axis_hdl->name.hasInheritedValue();
283     CTimer::get("XIOS").suspend();
284     return isDefined;
285  }
286
287
288  void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size)
289  {
290    std::string positive_str;
291    if (!cstr2string(positive, positive_size, positive_str)) return;
292    CTimer::get("XIOS").resume();
293    axis_hdl->positive.fromString(positive_str);
294    CTimer::get("XIOS").suspend();
295  }
296
297  void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)
298  {
299    CTimer::get("XIOS").resume();
300    if (!string_copy(axis_hdl->positive.getInheritedStringValue(), positive, positive_size))
301      ERROR("void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)", << "Input string is too short");
302    CTimer::get("XIOS").suspend();
303  }
304
305  bool cxios_is_defined_axis_positive(axis_Ptr axis_hdl)
306  {
307     CTimer::get("XIOS").resume();
308     bool isDefined = axis_hdl->positive.hasInheritedValue();
309     CTimer::get("XIOS").suspend();
310     return isDefined;
311  }
312
313
314  void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size)
315  {
316    std::string standard_name_str;
317    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
318    CTimer::get("XIOS").resume();
319    axis_hdl->standard_name.setValue(standard_name_str);
320    CTimer::get("XIOS").suspend();
321  }
322
323  void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)
324  {
325    CTimer::get("XIOS").resume();
326    if (!string_copy(axis_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
327      ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
328    CTimer::get("XIOS").suspend();
329  }
330
331  bool cxios_is_defined_axis_standard_name(axis_Ptr axis_hdl)
332  {
333     CTimer::get("XIOS").resume();
334     bool isDefined = axis_hdl->standard_name.hasInheritedValue();
335     CTimer::get("XIOS").suspend();
336     return isDefined;
337  }
338
339
340  void cxios_set_axis_unit(axis_Ptr axis_hdl, const char * unit, int unit_size)
341  {
342    std::string unit_str;
343    if (!cstr2string(unit, unit_size, unit_str)) return;
344    CTimer::get("XIOS").resume();
345    axis_hdl->unit.setValue(unit_str);
346    CTimer::get("XIOS").suspend();
347  }
348
349  void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)
350  {
351    CTimer::get("XIOS").resume();
352    if (!string_copy(axis_hdl->unit.getInheritedValue(), unit, unit_size))
353      ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", << "Input string is too short");
354    CTimer::get("XIOS").suspend();
355  }
356
357  bool cxios_is_defined_axis_unit(axis_Ptr axis_hdl)
358  {
359     CTimer::get("XIOS").resume();
360     bool isDefined = axis_hdl->unit.hasInheritedValue();
361     CTimer::get("XIOS").suspend();
362     return isDefined;
363  }
364
365
366  void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int* extent)
367  {
368    CTimer::get("XIOS").resume();
369    CArray<double,1> tmp(value, shape(extent[0]), neverDeleteData);
370    axis_hdl->value.reference(tmp.copy());
371     CTimer::get("XIOS").suspend();
372  }
373
374  void cxios_get_axis_value(axis_Ptr axis_hdl, double* value, int* extent)
375  {
376    CTimer::get("XIOS").resume();
377    CArray<double,1> tmp(value, shape(extent[0]), neverDeleteData);
378    tmp=axis_hdl->value.getInheritedValue();
379     CTimer::get("XIOS").suspend();
380  }
381
382  bool cxios_is_defined_axis_value(axis_Ptr axis_hdl)
383  {
384     CTimer::get("XIOS").resume();
385     bool isDefined = axis_hdl->value.hasInheritedValue();
386     CTimer::get("XIOS").suspend();
387     return isDefined;
388  }
389}
Note: See TracBrowser for help on using the repository browser.