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

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