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