source: XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp @ 329

Last change on this file since 329 was 325, checked in by ymipsl, 10 years ago

port to gfortran/g++

YM

  • Property svn:eol-style set to native
File size: 13.6 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_impl.hpp"
9#include "object_template_impl.hpp"
10#include "group_template_impl.hpp"
11#include "icutil.hpp"
12
13extern "C"
14{
15  typedef xmlioserver::tree::CDomain*  domain_Ptr;
16 
17  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
18  {
19    domain_hdl->data_dim.setValue(data_dim);
20    domain_hdl->sendAttributToServer(domain_hdl->data_dim);
21  }
22 
23  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim)
24  {
25    *data_dim = domain_hdl->data_dim.getValue();
26  }
27 
28 
29  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
30  {
31    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
32    std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data());
33    domain_hdl->data_i_index.setValue(array_tmp);
34    domain_hdl->sendAttributToServer(domain_hdl->data_i_index);
35  }
36 
37  void cxios_get_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
38  {
39    if (!array_copy(domain_hdl->data_i_index.getValue(), data_i_index, extent1))
40     ERROR("void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)",<<"Output array size is not conform to array size attribute") ;
41  }
42 
43 
44  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
45  {
46    domain_hdl->data_ibegin.setValue(data_ibegin);
47    domain_hdl->sendAttributToServer(domain_hdl->data_ibegin);
48  }
49 
50  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin)
51  {
52    *data_ibegin = domain_hdl->data_ibegin.getValue();
53  }
54 
55 
56  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)
57  {
58    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
59    std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data());
60    domain_hdl->data_j_index.setValue(array_tmp);
61    domain_hdl->sendAttributToServer(domain_hdl->data_j_index);
62  }
63 
64  void cxios_get_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)
65  {
66    if (!array_copy(domain_hdl->data_j_index.getValue(), data_j_index, extent1))
67     ERROR("void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)",<<"Output array size is not conform to array size attribute") ;
68  }
69 
70 
71  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
72  {
73    domain_hdl->data_jbegin.setValue(data_jbegin);
74    domain_hdl->sendAttributToServer(domain_hdl->data_jbegin);
75  }
76 
77  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin)
78  {
79    *data_jbegin = domain_hdl->data_jbegin.getValue();
80  }
81 
82 
83  void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index)
84  {
85    domain_hdl->data_n_index.setValue(data_n_index);
86    domain_hdl->sendAttributToServer(domain_hdl->data_n_index);
87  }
88 
89  void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index)
90  {
91    *data_n_index = domain_hdl->data_n_index.getValue();
92  }
93 
94 
95  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
96  {
97    domain_hdl->data_ni.setValue(data_ni);
98    domain_hdl->sendAttributToServer(domain_hdl->data_ni);
99  }
100 
101  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni)
102  {
103    *data_ni = domain_hdl->data_ni.getValue();
104  }
105 
106 
107  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
108  {
109    domain_hdl->data_nj.setValue(data_nj);
110    domain_hdl->sendAttributToServer(domain_hdl->data_nj);
111  }
112 
113  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj)
114  {
115    *data_nj = domain_hdl->data_nj.getValue();
116  }
117 
118 
119  void cxios_set_domain_domain_group_ref(domain_Ptr domain_hdl, const char * domain_group_ref, int domain_group_ref_size)
120  {
121    std::string domain_group_ref_str;
122    if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
123    domain_hdl->domain_group_ref.setValue(domain_group_ref_str);
124    domain_hdl->sendAttributToServer(domain_hdl->domain_group_ref);
125  }
126 
127  void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)
128  {
129    if(!string_copy(domain_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size))
130      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short");
131  }
132 
133 
134  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
135  {
136    domain_hdl->ibegin.setValue(ibegin);
137    domain_hdl->sendAttributToServer(domain_hdl->ibegin);
138  }
139 
140  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin)
141  {
142    *ibegin = domain_hdl->ibegin.getValue();
143  }
144 
145 
146  void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend)
147  {
148    domain_hdl->iend.setValue(iend);
149    domain_hdl->sendAttributToServer(domain_hdl->iend);
150  }
151 
152  void cxios_get_domain_iend(domain_Ptr domain_hdl, int* iend)
153  {
154    *iend = domain_hdl->iend.getValue();
155  }
156 
157 
158  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
159  {
160    domain_hdl->jbegin.setValue(jbegin);
161    domain_hdl->sendAttributToServer(domain_hdl->jbegin);
162  }
163 
164  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin)
165  {
166    *jbegin = domain_hdl->jbegin.getValue();
167  }
168 
169 
170  void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend)
171  {
172    domain_hdl->jend.setValue(jend);
173    domain_hdl->sendAttributToServer(domain_hdl->jend);
174  }
175 
176  void cxios_get_domain_jend(domain_Ptr domain_hdl, int* jend)
177  {
178    *jend = domain_hdl->jend.getValue();
179  }
180 
181 
182  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
183  {
184    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
185    std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data());
186    domain_hdl->latvalue.setValue(array_tmp);
187    domain_hdl->sendAttributToServer(domain_hdl->latvalue);
188  }
189 
190  void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
191  {
192    if (!array_copy(domain_hdl->latvalue.getValue(), latvalue, extent1))
193     ERROR("void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
194  }
195 
196 
197  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
198  {
199    std::string long_name_str;
200    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
201    domain_hdl->long_name.setValue(long_name_str);
202    domain_hdl->sendAttributToServer(domain_hdl->long_name);
203  }
204 
205  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
206  {
207    if(!string_copy(domain_hdl->long_name.getValue(),long_name , long_name_size))
208      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
209  }
210 
211 
212  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
213  {
214    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
215    std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data());
216    domain_hdl->lonvalue.setValue(array_tmp);
217    domain_hdl->sendAttributToServer(domain_hdl->lonvalue);
218  }
219 
220  void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
221  {
222    if (!array_copy(domain_hdl->lonvalue.getValue(), lonvalue, extent1))
223     ERROR("void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
224  }
225 
226 
227  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
228  {
229    ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2]));
230    std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data());
231    domain_hdl->mask.setValue(array_tmp);
232    domain_hdl->sendAttributToServer(domain_hdl->mask);
233  }
234 
235  void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
236  {
237    if (!array_copy(domain_hdl->mask.getValue(), mask, extent1, extent2))
238     ERROR("void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)",<<"Output array size is not conform to array size attribute") ;
239  }
240 
241 
242  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
243  {
244    std::string name_str;
245    if(!cstr2string(name, name_size, name_str)) return;
246    domain_hdl->name.setValue(name_str);
247    domain_hdl->sendAttributToServer(domain_hdl->name);
248  }
249 
250  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
251  {
252    if(!string_copy(domain_hdl->name.getValue(),name , name_size))
253      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short");
254  }
255 
256 
257  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
258  {
259    domain_hdl->ni.setValue(ni);
260    domain_hdl->sendAttributToServer(domain_hdl->ni);
261  }
262 
263  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni)
264  {
265    *ni = domain_hdl->ni.getValue();
266  }
267 
268 
269  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
270  {
271    domain_hdl->ni_glo.setValue(ni_glo);
272    domain_hdl->sendAttributToServer(domain_hdl->ni_glo);
273  }
274 
275  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo)
276  {
277    *ni_glo = domain_hdl->ni_glo.getValue();
278  }
279 
280 
281  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
282  {
283    domain_hdl->nj.setValue(nj);
284    domain_hdl->sendAttributToServer(domain_hdl->nj);
285  }
286 
287  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj)
288  {
289    *nj = domain_hdl->nj.getValue();
290  }
291 
292 
293  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
294  {
295    domain_hdl->nj_glo.setValue(nj_glo);
296    domain_hdl->sendAttributToServer(domain_hdl->nj_glo);
297  }
298 
299  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo)
300  {
301    *nj_glo = domain_hdl->nj_glo.getValue();
302  }
303 
304 
305  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
306  {
307    std::string standard_name_str;
308    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
309    domain_hdl->standard_name.setValue(standard_name_str);
310    domain_hdl->sendAttributToServer(domain_hdl->standard_name);
311  }
312 
313  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
314  {
315    if(!string_copy(domain_hdl->standard_name.getValue(),standard_name , standard_name_size))
316      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
317  }
318 
319 
320  void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin)
321  {
322    domain_hdl->zoom_ibegin.setValue(zoom_ibegin);
323    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin);
324  }
325 
326  void cxios_get_domain_zoom_ibegin(domain_Ptr domain_hdl, int* zoom_ibegin)
327  {
328    *zoom_ibegin = domain_hdl->zoom_ibegin.getValue();
329  }
330 
331 
332  void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc)
333  {
334    domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
335    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin_loc);
336  }
337 
338  void cxios_get_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int* zoom_ibegin_loc)
339  {
340    *zoom_ibegin_loc = domain_hdl->zoom_ibegin_loc.getValue();
341  }
342 
343 
344  void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin)
345  {
346    domain_hdl->zoom_jbegin.setValue(zoom_jbegin);
347    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin);
348  }
349 
350  void cxios_get_domain_zoom_jbegin(domain_Ptr domain_hdl, int* zoom_jbegin)
351  {
352    *zoom_jbegin = domain_hdl->zoom_jbegin.getValue();
353  }
354 
355 
356  void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc)
357  {
358    domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
359    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin_loc);
360  }
361 
362  void cxios_get_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int* zoom_jbegin_loc)
363  {
364    *zoom_jbegin_loc = domain_hdl->zoom_jbegin_loc.getValue();
365  }
366 
367 
368  void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni)
369  {
370    domain_hdl->zoom_ni.setValue(zoom_ni);
371    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni);
372  }
373 
374  void cxios_get_domain_zoom_ni(domain_Ptr domain_hdl, int* zoom_ni)
375  {
376    *zoom_ni = domain_hdl->zoom_ni.getValue();
377  }
378 
379 
380  void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc)
381  {
382    domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
383    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni_loc);
384  }
385 
386  void cxios_get_domain_zoom_ni_loc(domain_Ptr domain_hdl, int* zoom_ni_loc)
387  {
388    *zoom_ni_loc = domain_hdl->zoom_ni_loc.getValue();
389  }
390 
391 
392  void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj)
393  {
394    domain_hdl->zoom_nj.setValue(zoom_nj);
395    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj);
396  }
397 
398  void cxios_get_domain_zoom_nj(domain_Ptr domain_hdl, int* zoom_nj)
399  {
400    *zoom_nj = domain_hdl->zoom_nj.getValue();
401  }
402 
403 
404  void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc)
405  {
406    domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
407    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj_loc);
408  }
409 
410  void cxios_get_domain_zoom_nj_loc(domain_Ptr domain_hdl, int* zoom_nj_loc)
411  {
412    *zoom_nj_loc = domain_hdl->zoom_nj_loc.getValue();
413  }
414 
415 
416 
417}
Note: See TracBrowser for help on using the repository browser.