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

Last change on this file since 347 was 347, checked in by ymipsl, 10 years ago
  • Supress lot of shared_ptr
  • instrument code for vampir-trace and timer diagnostic

YM

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