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

Last change on this file since 416 was 416, checked in by ymipsl, 9 years ago

add some missing trace in c interface

YM

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