source: XIOS/branchs/xios-1.0/src/interface/c_attr/icaxisgroup_attr.cpp @ 581

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

Fix the Fortran interface generation to avoid generating dead code that caused a timer not to be stopped.

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