source: XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp @ 546

Last change on this file since 546 was 546, checked in by rlacroix, 7 years ago

Update the Fortran interface after r540.

  • 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: 10.2 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 "icdate.hpp"
13#include "timer.hpp"
14#include "node_type.hpp"
15
16extern "C"
17{
18  typedef xios::CAxisGroup*  axisgroup_Ptr;
19 
20  void cxios_set_axisgroup_axis_ref(axisgroup_Ptr axisgroup_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    axisgroup_hdl->axis_ref.setValue(axis_ref_str);
26     CTimer::get("XIOS").suspend();
27  }
28 
29  void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)
30  {
31     CTimer::get("XIOS").resume();
32    if(!string_copy(axisgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size))
33      ERROR("void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
34     CTimer::get("XIOS").suspend();
35  }
36 
37  bool cxios_is_defined_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl )
38  {
39     CTimer::get("XIOS").resume();
40    return axisgroup_hdl->axis_ref.hasInheritedValue();
41     CTimer::get("XIOS").suspend();
42  }
43 
44 
45 
46  void cxios_set_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, const char * group_ref, int group_ref_size)
47  {
48    std::string group_ref_str;
49    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
50     CTimer::get("XIOS").resume();
51    axisgroup_hdl->group_ref.setValue(group_ref_str);
52     CTimer::get("XIOS").suspend();
53  }
54 
55  void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)
56  {
57     CTimer::get("XIOS").resume();
58    if(!string_copy(axisgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size))
59      ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
60     CTimer::get("XIOS").suspend();
61  }
62 
63  bool cxios_is_defined_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl )
64  {
65     CTimer::get("XIOS").resume();
66    return axisgroup_hdl->group_ref.hasInheritedValue();
67     CTimer::get("XIOS").suspend();
68  }
69 
70 
71 
72  void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size)
73  {
74    std::string long_name_str;
75    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
76     CTimer::get("XIOS").resume();
77    axisgroup_hdl->long_name.setValue(long_name_str);
78     CTimer::get("XIOS").suspend();
79  }
80 
81  void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)
82  {
83     CTimer::get("XIOS").resume();
84    if(!string_copy(axisgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size))
85      ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
86     CTimer::get("XIOS").suspend();
87  }
88 
89  bool cxios_is_defined_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl )
90  {
91     CTimer::get("XIOS").resume();
92    return axisgroup_hdl->long_name.hasInheritedValue();
93     CTimer::get("XIOS").suspend();
94  }
95 
96 
97 
98  void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size)
99  {
100    std::string name_str;
101    if(!cstr2string(name, name_size, name_str)) return;
102     CTimer::get("XIOS").resume();
103    axisgroup_hdl->name.setValue(name_str);
104     CTimer::get("XIOS").suspend();
105  }
106 
107  void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)
108  {
109     CTimer::get("XIOS").resume();
110    if(!string_copy(axisgroup_hdl->name.getInheritedValue(),name , name_size))
111      ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", <<"Input string is to short");
112     CTimer::get("XIOS").suspend();
113  }
114 
115  bool cxios_is_defined_axisgroup_name(axisgroup_Ptr axisgroup_hdl )
116  {
117     CTimer::get("XIOS").resume();
118    return axisgroup_hdl->name.hasInheritedValue();
119     CTimer::get("XIOS").suspend();
120  }
121 
122 
123 
124  void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size)
125  {
126    std::string positive_str;
127    if(!cstr2string(positive, positive_size, positive_str)) return;
128     CTimer::get("XIOS").resume();
129    axisgroup_hdl->positive.fromString(positive_str);
130     CTimer::get("XIOS").suspend();
131  }
132 
133  void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)
134  {
135     CTimer::get("XIOS").resume();
136    if(!string_copy(axisgroup_hdl->positive.getInheritedStringValue(),positive , positive_size))
137      ERROR("void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)", <<"Input string is to short");
138     CTimer::get("XIOS").suspend();
139  }
140 
141  bool cxios_is_defined_axisgroup_positive(axisgroup_Ptr axisgroup_hdl )
142  {
143     CTimer::get("XIOS").resume();
144    return axisgroup_hdl->positive.hasInheritedValue();
145     CTimer::get("XIOS").suspend();
146  }
147 
148 
149 
150  void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size)
151  {
152     CTimer::get("XIOS").resume();
153    axisgroup_hdl->size.setValue(size);
154     CTimer::get("XIOS").suspend();
155  }
156 
157  void cxios_get_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int* size)
158  {
159    *size = axisgroup_hdl->size.getInheritedValue();
160  }
161 
162  bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl )
163  {
164     CTimer::get("XIOS").resume();
165    return axisgroup_hdl->size.hasInheritedValue();
166     CTimer::get("XIOS").suspend();
167  }
168 
169 
170 
171  void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size)
172  {
173    std::string standard_name_str;
174    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
175     CTimer::get("XIOS").resume();
176    axisgroup_hdl->standard_name.setValue(standard_name_str);
177     CTimer::get("XIOS").suspend();
178  }
179 
180  void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)
181  {
182     CTimer::get("XIOS").resume();
183    if(!string_copy(axisgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
184      ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
185     CTimer::get("XIOS").suspend();
186  }
187 
188  bool cxios_is_defined_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl )
189  {
190     CTimer::get("XIOS").resume();
191    return axisgroup_hdl->standard_name.hasInheritedValue();
192     CTimer::get("XIOS").suspend();
193  }
194 
195 
196 
197  void cxios_set_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, const char * unit, int unit_size)
198  {
199    std::string unit_str;
200    if(!cstr2string(unit, unit_size, unit_str)) return;
201     CTimer::get("XIOS").resume();
202    axisgroup_hdl->unit.setValue(unit_str);
203     CTimer::get("XIOS").suspend();
204  }
205 
206  void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)
207  {
208     CTimer::get("XIOS").resume();
209    if(!string_copy(axisgroup_hdl->unit.getInheritedValue(),unit , unit_size))
210      ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
211     CTimer::get("XIOS").suspend();
212  }
213 
214  bool cxios_is_defined_axisgroup_unit(axisgroup_Ptr axisgroup_hdl )
215  {
216     CTimer::get("XIOS").resume();
217    return axisgroup_hdl->unit.hasInheritedValue();
218     CTimer::get("XIOS").suspend();
219  }
220 
221 
222 
223  void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)
224  {
225    CTimer::get("XIOS").resume();
226    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ;
227    axisgroup_hdl->value.reference(tmp.copy());
228     CTimer::get("XIOS").suspend();
229  }
230 
231  void cxios_get_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)
232  {
233    CTimer::get("XIOS").resume();
234    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ;
235    tmp=axisgroup_hdl->value.getInheritedValue() ;
236     CTimer::get("XIOS").suspend();
237  }
238 
239  bool cxios_is_defined_axisgroup_value(axisgroup_Ptr axisgroup_hdl )
240  {
241     CTimer::get("XIOS").resume();
242    return axisgroup_hdl->value.hasInheritedValue();
243     CTimer::get("XIOS").suspend();
244  }
245 
246 
247 
248  void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin)
249  {
250     CTimer::get("XIOS").resume();
251    axisgroup_hdl->zoom_begin.setValue(zoom_begin);
252     CTimer::get("XIOS").suspend();
253  }
254 
255  void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin)
256  {
257    *zoom_begin = axisgroup_hdl->zoom_begin.getInheritedValue();
258  }
259 
260  bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl )
261  {
262     CTimer::get("XIOS").resume();
263    return axisgroup_hdl->zoom_begin.hasInheritedValue();
264     CTimer::get("XIOS").suspend();
265  }
266 
267 
268 
269  void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end)
270  {
271     CTimer::get("XIOS").resume();
272    axisgroup_hdl->zoom_end.setValue(zoom_end);
273     CTimer::get("XIOS").suspend();
274  }
275 
276  void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end)
277  {
278    *zoom_end = axisgroup_hdl->zoom_end.getInheritedValue();
279  }
280 
281  bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl )
282  {
283     CTimer::get("XIOS").resume();
284    return axisgroup_hdl->zoom_end.hasInheritedValue();
285     CTimer::get("XIOS").suspend();
286  }
287 
288 
289 
290  void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size)
291  {
292     CTimer::get("XIOS").resume();
293    axisgroup_hdl->zoom_size.setValue(zoom_size);
294     CTimer::get("XIOS").suspend();
295  }
296 
297  void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size)
298  {
299    *zoom_size = axisgroup_hdl->zoom_size.getInheritedValue();
300  }
301 
302  bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl )
303  {
304     CTimer::get("XIOS").resume();
305    return axisgroup_hdl->zoom_size.hasInheritedValue();
306     CTimer::get("XIOS").suspend();
307  }
308 
309 
310 
311 
312}
Note: See TracBrowser for help on using the repository browser.