source: XIOS/branchs/xios-1.0/src/interface/c_attr/icaxis_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: 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.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::CAxis*  axis_Ptr;
18 
19  void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size)
20  {
21    std::string long_name_str;
22    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
23     CTimer::get("XIOS").resume();
24    axis_hdl->long_name.setValue(long_name_str);
25    axis_hdl->sendAttributToServer(axis_hdl->long_name);
26     CTimer::get("XIOS").suspend();
27  }
28 
29  void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)
30  {
31     CTimer::get("XIOS").resume();
32    if(!string_copy(axis_hdl->long_name.getInheritedValue(),long_name , long_name_size))
33      ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
34     CTimer::get("XIOS").suspend();
35  }
36 
37  bool cxios_is_defined_axis_long_name(axis_Ptr axis_hdl )
38  {
39    CTimer::get("XIOS").resume();
40    bool isDefined = axis_hdl->long_name.hasInheritedValue();
41    CTimer::get("XIOS").suspend();
42    return isDefined;
43  }
44 
45 
46 
47  void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size)
48  {
49    std::string name_str;
50    if(!cstr2string(name, name_size, name_str)) return;
51     CTimer::get("XIOS").resume();
52    axis_hdl->name.setValue(name_str);
53    axis_hdl->sendAttributToServer(axis_hdl->name);
54     CTimer::get("XIOS").suspend();
55  }
56 
57  void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)
58  {
59     CTimer::get("XIOS").resume();
60    if(!string_copy(axis_hdl->name.getInheritedValue(),name , name_size))
61      ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", <<"Input string is to short");
62     CTimer::get("XIOS").suspend();
63  }
64 
65  bool cxios_is_defined_axis_name(axis_Ptr axis_hdl )
66  {
67    CTimer::get("XIOS").resume();
68    bool isDefined = axis_hdl->name.hasInheritedValue();
69    CTimer::get("XIOS").suspend();
70    return isDefined;
71  }
72 
73 
74 
75  void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size)
76  {
77    std::string positive_str;
78    if(!cstr2string(positive, positive_size, positive_str)) return;
79     CTimer::get("XIOS").resume();
80    axis_hdl->positive.fromString(positive_str);
81    axis_hdl->sendAttributToServer(axis_hdl->positive);
82     CTimer::get("XIOS").suspend();
83  }
84 
85  void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)
86  {
87     CTimer::get("XIOS").resume();
88    if(!string_copy(axis_hdl->positive.getInheritedStringValue(),positive , positive_size))
89      ERROR("void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)", <<"Input string is to short");
90     CTimer::get("XIOS").suspend();
91  }
92 
93  bool cxios_is_defined_axis_positive(axis_Ptr axis_hdl )
94  {
95    CTimer::get("XIOS").resume();
96    bool isDefined = axis_hdl->positive.hasInheritedValue();
97    CTimer::get("XIOS").suspend();
98    return isDefined;
99  }
100 
101 
102 
103  void cxios_set_axis_size(axis_Ptr axis_hdl, int size)
104  {
105     CTimer::get("XIOS").resume();
106    axis_hdl->size.setValue(size);
107    axis_hdl->sendAttributToServer(axis_hdl->size);
108     CTimer::get("XIOS").suspend();
109  }
110 
111  void cxios_get_axis_size(axis_Ptr axis_hdl, int* size)
112  {
113    *size = axis_hdl->size.getInheritedValue();
114  }
115 
116  bool cxios_is_defined_axis_size(axis_Ptr axis_hdl )
117  {
118    CTimer::get("XIOS").resume();
119    bool isDefined = axis_hdl->size.hasInheritedValue();
120    CTimer::get("XIOS").suspend();
121    return isDefined;
122  }
123 
124 
125 
126  void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size)
127  {
128    std::string standard_name_str;
129    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
130     CTimer::get("XIOS").resume();
131    axis_hdl->standard_name.setValue(standard_name_str);
132    axis_hdl->sendAttributToServer(axis_hdl->standard_name);
133     CTimer::get("XIOS").suspend();
134  }
135 
136  void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)
137  {
138     CTimer::get("XIOS").resume();
139    if(!string_copy(axis_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
140      ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
141     CTimer::get("XIOS").suspend();
142  }
143 
144  bool cxios_is_defined_axis_standard_name(axis_Ptr axis_hdl )
145  {
146    CTimer::get("XIOS").resume();
147    bool isDefined = axis_hdl->standard_name.hasInheritedValue();
148    CTimer::get("XIOS").suspend();
149    return isDefined;
150  }
151 
152 
153 
154  void cxios_set_axis_unit(axis_Ptr axis_hdl, const char * unit, int unit_size)
155  {
156    std::string unit_str;
157    if(!cstr2string(unit, unit_size, unit_str)) return;
158     CTimer::get("XIOS").resume();
159    axis_hdl->unit.setValue(unit_str);
160    axis_hdl->sendAttributToServer(axis_hdl->unit);
161     CTimer::get("XIOS").suspend();
162  }
163 
164  void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)
165  {
166     CTimer::get("XIOS").resume();
167    if(!string_copy(axis_hdl->unit.getInheritedValue(),unit , unit_size))
168      ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", <<"Input string is to short");
169     CTimer::get("XIOS").suspend();
170  }
171 
172  bool cxios_is_defined_axis_unit(axis_Ptr axis_hdl )
173  {
174    CTimer::get("XIOS").resume();
175    bool isDefined = axis_hdl->unit.hasInheritedValue();
176    CTimer::get("XIOS").suspend();
177    return isDefined;
178  }
179 
180 
181 
182  void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1)
183  {
184    CTimer::get("XIOS").resume();
185    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ;
186    axis_hdl->value.reference(tmp.copy());
187    axis_hdl->sendAttributToServer(axis_hdl->value);
188     CTimer::get("XIOS").suspend();
189  }
190 
191  void cxios_get_axis_value(axis_Ptr axis_hdl, double* value, int extent1)
192  {
193    CTimer::get("XIOS").resume();
194    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ;
195    tmp=axis_hdl->value.getInheritedValue() ;
196     CTimer::get("XIOS").suspend();
197  }
198 
199  bool cxios_is_defined_axis_value(axis_Ptr axis_hdl )
200  {
201    CTimer::get("XIOS").resume();
202    bool isDefined = axis_hdl->value.hasInheritedValue();
203    CTimer::get("XIOS").suspend();
204    return isDefined;
205  }
206 
207 
208 
209  void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin)
210  {
211     CTimer::get("XIOS").resume();
212    axis_hdl->zoom_begin.setValue(zoom_begin);
213    axis_hdl->sendAttributToServer(axis_hdl->zoom_begin);
214     CTimer::get("XIOS").suspend();
215  }
216 
217  void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin)
218  {
219    *zoom_begin = axis_hdl->zoom_begin.getInheritedValue();
220  }
221 
222  bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl )
223  {
224    CTimer::get("XIOS").resume();
225    bool isDefined = axis_hdl->zoom_begin.hasInheritedValue();
226    CTimer::get("XIOS").suspend();
227    return isDefined;
228  }
229 
230 
231 
232  void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end)
233  {
234     CTimer::get("XIOS").resume();
235    axis_hdl->zoom_end.setValue(zoom_end);
236    axis_hdl->sendAttributToServer(axis_hdl->zoom_end);
237     CTimer::get("XIOS").suspend();
238  }
239 
240  void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end)
241  {
242    *zoom_end = axis_hdl->zoom_end.getInheritedValue();
243  }
244 
245  bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl )
246  {
247    CTimer::get("XIOS").resume();
248    bool isDefined = axis_hdl->zoom_end.hasInheritedValue();
249    CTimer::get("XIOS").suspend();
250    return isDefined;
251  }
252 
253 
254 
255  void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size)
256  {
257     CTimer::get("XIOS").resume();
258    axis_hdl->zoom_size.setValue(zoom_size);
259    axis_hdl->sendAttributToServer(axis_hdl->zoom_size);
260     CTimer::get("XIOS").suspend();
261  }
262 
263  void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size)
264  {
265    *zoom_size = axis_hdl->zoom_size.getInheritedValue();
266  }
267 
268  bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl )
269  {
270    CTimer::get("XIOS").resume();
271    bool isDefined = axis_hdl->zoom_size.hasInheritedValue();
272    CTimer::get("XIOS").suspend();
273    return isDefined;
274  }
275 
276 
277 
278 
279}
Note: See TracBrowser for help on using the repository browser.