source: XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp @ 432

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

Enhancement : Add fortran interface to know if an attribute is set or not
ex : CALL xios_is_defined_field_attr("field_A",enabled=ok)

YM

  • Property svn:eol-style set to native
File size: 24.4 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::CDomainGroup*  domaingroup_Ptr;
18 
19  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim)
20  {
21     CTimer::get("XIOS").resume();
22    domaingroup_hdl->data_dim.setValue(data_dim);
23    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_dim);
24     CTimer::get("XIOS").suspend();
25  }
26 
27  void cxios_get_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int* data_dim)
28  {
29    *data_dim = domaingroup_hdl->data_dim.getValue();
30  }
31 
32  bool cxios_is_defined_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl )
33  {
34     CTimer::get("XIOS").resume();
35    return !domaingroup_hdl->data_dim.isEmpty();
36     CTimer::get("XIOS").suspend();
37  }
38 
39 
40 
41  void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
42  {
43    CTimer::get("XIOS").resume();
44    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ;
45    domaingroup_hdl->data_i_index.reference(tmp.copy());
46    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_i_index);
47     CTimer::get("XIOS").suspend();
48  }
49 
50  void cxios_get_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
51  {
52    CTimer::get("XIOS").resume();
53    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ;
54    tmp=domaingroup_hdl->data_i_index ;
55     CTimer::get("XIOS").suspend();
56  }
57 
58  bool cxios_is_defined_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl )
59  {
60     CTimer::get("XIOS").resume();
61    return !domaingroup_hdl->data_i_index.isEmpty();
62     CTimer::get("XIOS").suspend();
63  }
64 
65 
66 
67  void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin)
68  {
69     CTimer::get("XIOS").resume();
70    domaingroup_hdl->data_ibegin.setValue(data_ibegin);
71    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ibegin);
72     CTimer::get("XIOS").suspend();
73  }
74 
75  void cxios_get_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* data_ibegin)
76  {
77    *data_ibegin = domaingroup_hdl->data_ibegin.getValue();
78  }
79 
80  bool cxios_is_defined_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl )
81  {
82     CTimer::get("XIOS").resume();
83    return !domaingroup_hdl->data_ibegin.isEmpty();
84     CTimer::get("XIOS").suspend();
85  }
86 
87 
88 
89  void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)
90  {
91    CTimer::get("XIOS").resume();
92    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ;
93    domaingroup_hdl->data_j_index.reference(tmp.copy());
94    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_j_index);
95     CTimer::get("XIOS").suspend();
96  }
97 
98  void cxios_get_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)
99  {
100    CTimer::get("XIOS").resume();
101    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ;
102    tmp=domaingroup_hdl->data_j_index ;
103     CTimer::get("XIOS").suspend();
104  }
105 
106  bool cxios_is_defined_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl )
107  {
108     CTimer::get("XIOS").resume();
109    return !domaingroup_hdl->data_j_index.isEmpty();
110     CTimer::get("XIOS").suspend();
111  }
112 
113 
114 
115  void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin)
116  {
117     CTimer::get("XIOS").resume();
118    domaingroup_hdl->data_jbegin.setValue(data_jbegin);
119    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_jbegin);
120     CTimer::get("XIOS").suspend();
121  }
122 
123  void cxios_get_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* data_jbegin)
124  {
125    *data_jbegin = domaingroup_hdl->data_jbegin.getValue();
126  }
127 
128  bool cxios_is_defined_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl )
129  {
130     CTimer::get("XIOS").resume();
131    return !domaingroup_hdl->data_jbegin.isEmpty();
132     CTimer::get("XIOS").suspend();
133  }
134 
135 
136 
137  void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index)
138  {
139     CTimer::get("XIOS").resume();
140    domaingroup_hdl->data_n_index.setValue(data_n_index);
141    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_n_index);
142     CTimer::get("XIOS").suspend();
143  }
144 
145  void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index)
146  {
147    *data_n_index = domaingroup_hdl->data_n_index.getValue();
148  }
149 
150  bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl )
151  {
152     CTimer::get("XIOS").resume();
153    return !domaingroup_hdl->data_n_index.isEmpty();
154     CTimer::get("XIOS").suspend();
155  }
156 
157 
158 
159  void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni)
160  {
161     CTimer::get("XIOS").resume();
162    domaingroup_hdl->data_ni.setValue(data_ni);
163    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ni);
164     CTimer::get("XIOS").suspend();
165  }
166 
167  void cxios_get_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int* data_ni)
168  {
169    *data_ni = domaingroup_hdl->data_ni.getValue();
170  }
171 
172  bool cxios_is_defined_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl )
173  {
174     CTimer::get("XIOS").resume();
175    return !domaingroup_hdl->data_ni.isEmpty();
176     CTimer::get("XIOS").suspend();
177  }
178 
179 
180 
181  void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj)
182  {
183     CTimer::get("XIOS").resume();
184    domaingroup_hdl->data_nj.setValue(data_nj);
185    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_nj);
186     CTimer::get("XIOS").suspend();
187  }
188 
189  void cxios_get_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int* data_nj)
190  {
191    *data_nj = domaingroup_hdl->data_nj.getValue();
192  }
193 
194  bool cxios_is_defined_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl )
195  {
196     CTimer::get("XIOS").resume();
197    return !domaingroup_hdl->data_nj.isEmpty();
198     CTimer::get("XIOS").suspend();
199  }
200 
201 
202 
203  void cxios_set_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size)
204  {
205    std::string domain_group_ref_str;
206    if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
207     CTimer::get("XIOS").resume();
208    domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str);
209    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->domain_group_ref);
210     CTimer::get("XIOS").suspend();
211  }
212 
213  void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)
214  {
215     CTimer::get("XIOS").resume();
216    if(!string_copy(domaingroup_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size))
217      ERROR("void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short");
218     CTimer::get("XIOS").suspend();
219  }
220 
221  bool cxios_is_defined_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl )
222  {
223     CTimer::get("XIOS").resume();
224    return !domaingroup_hdl->domain_group_ref.isEmpty();
225     CTimer::get("XIOS").suspend();
226  }
227 
228 
229 
230  void cxios_set_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, const char * group_ref, int group_ref_size)
231  {
232    std::string group_ref_str;
233    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
234     CTimer::get("XIOS").resume();
235    domaingroup_hdl->group_ref.setValue(group_ref_str);
236    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->group_ref);
237     CTimer::get("XIOS").suspend();
238  }
239 
240  void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)
241  {
242     CTimer::get("XIOS").resume();
243    if(!string_copy(domaingroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
244      ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
245     CTimer::get("XIOS").suspend();
246  }
247 
248  bool cxios_is_defined_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl )
249  {
250     CTimer::get("XIOS").resume();
251    return !domaingroup_hdl->group_ref.isEmpty();
252     CTimer::get("XIOS").suspend();
253  }
254 
255 
256 
257  void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin)
258  {
259     CTimer::get("XIOS").resume();
260    domaingroup_hdl->ibegin.setValue(ibegin);
261    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ibegin);
262     CTimer::get("XIOS").suspend();
263  }
264 
265  void cxios_get_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int* ibegin)
266  {
267    *ibegin = domaingroup_hdl->ibegin.getValue();
268  }
269 
270  bool cxios_is_defined_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl )
271  {
272     CTimer::get("XIOS").resume();
273    return !domaingroup_hdl->ibegin.isEmpty();
274     CTimer::get("XIOS").suspend();
275  }
276 
277 
278 
279  void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend)
280  {
281     CTimer::get("XIOS").resume();
282    domaingroup_hdl->iend.setValue(iend);
283    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->iend);
284     CTimer::get("XIOS").suspend();
285  }
286 
287  void cxios_get_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int* iend)
288  {
289    *iend = domaingroup_hdl->iend.getValue();
290  }
291 
292  bool cxios_is_defined_domaingroup_iend(domaingroup_Ptr domaingroup_hdl )
293  {
294     CTimer::get("XIOS").resume();
295    return !domaingroup_hdl->iend.isEmpty();
296     CTimer::get("XIOS").suspend();
297  }
298 
299 
300 
301  void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin)
302  {
303     CTimer::get("XIOS").resume();
304    domaingroup_hdl->jbegin.setValue(jbegin);
305    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jbegin);
306     CTimer::get("XIOS").suspend();
307  }
308 
309  void cxios_get_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int* jbegin)
310  {
311    *jbegin = domaingroup_hdl->jbegin.getValue();
312  }
313 
314  bool cxios_is_defined_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl )
315  {
316     CTimer::get("XIOS").resume();
317    return !domaingroup_hdl->jbegin.isEmpty();
318     CTimer::get("XIOS").suspend();
319  }
320 
321 
322 
323  void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend)
324  {
325     CTimer::get("XIOS").resume();
326    domaingroup_hdl->jend.setValue(jend);
327    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jend);
328     CTimer::get("XIOS").suspend();
329  }
330 
331  void cxios_get_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int* jend)
332  {
333    *jend = domaingroup_hdl->jend.getValue();
334  }
335 
336  bool cxios_is_defined_domaingroup_jend(domaingroup_Ptr domaingroup_hdl )
337  {
338     CTimer::get("XIOS").resume();
339    return !domaingroup_hdl->jend.isEmpty();
340     CTimer::get("XIOS").suspend();
341  }
342 
343 
344 
345  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
346  {
347    CTimer::get("XIOS").resume();
348    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
349    domaingroup_hdl->latvalue.reference(tmp.copy());
350    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->latvalue);
351     CTimer::get("XIOS").suspend();
352  }
353 
354  void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
355  {
356    CTimer::get("XIOS").resume();
357    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
358    tmp=domaingroup_hdl->latvalue ;
359     CTimer::get("XIOS").suspend();
360  }
361 
362  bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl )
363  {
364     CTimer::get("XIOS").resume();
365    return !domaingroup_hdl->latvalue.isEmpty();
366     CTimer::get("XIOS").suspend();
367  }
368 
369 
370 
371  void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size)
372  {
373    std::string long_name_str;
374    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
375     CTimer::get("XIOS").resume();
376    domaingroup_hdl->long_name.setValue(long_name_str);
377    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->long_name);
378     CTimer::get("XIOS").suspend();
379  }
380 
381  void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)
382  {
383     CTimer::get("XIOS").resume();
384    if(!string_copy(domaingroup_hdl->long_name.getValue(),long_name , long_name_size))
385      ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
386     CTimer::get("XIOS").suspend();
387  }
388 
389  bool cxios_is_defined_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl )
390  {
391     CTimer::get("XIOS").resume();
392    return !domaingroup_hdl->long_name.isEmpty();
393     CTimer::get("XIOS").suspend();
394  }
395 
396 
397 
398  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
399  {
400    CTimer::get("XIOS").resume();
401    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
402    domaingroup_hdl->lonvalue.reference(tmp.copy());
403    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->lonvalue);
404     CTimer::get("XIOS").suspend();
405  }
406 
407  void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
408  {
409    CTimer::get("XIOS").resume();
410    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
411    tmp=domaingroup_hdl->lonvalue ;
412     CTimer::get("XIOS").suspend();
413  }
414 
415  bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl )
416  {
417     CTimer::get("XIOS").resume();
418    return !domaingroup_hdl->lonvalue.isEmpty();
419     CTimer::get("XIOS").suspend();
420  }
421 
422 
423 
424  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
425  {
426    CTimer::get("XIOS").resume();
427    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
428    domaingroup_hdl->mask.reference(tmp.copy());
429    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->mask);
430     CTimer::get("XIOS").suspend();
431  }
432 
433  void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
434  {
435    CTimer::get("XIOS").resume();
436    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
437    tmp=domaingroup_hdl->mask ;
438     CTimer::get("XIOS").suspend();
439  }
440 
441  bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl )
442  {
443     CTimer::get("XIOS").resume();
444    return !domaingroup_hdl->mask.isEmpty();
445     CTimer::get("XIOS").suspend();
446  }
447 
448 
449 
450  void cxios_set_domaingroup_name(domaingroup_Ptr domaingroup_hdl, const char * name, int name_size)
451  {
452    std::string name_str;
453    if(!cstr2string(name, name_size, name_str)) return;
454     CTimer::get("XIOS").resume();
455    domaingroup_hdl->name.setValue(name_str);
456    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->name);
457     CTimer::get("XIOS").suspend();
458  }
459 
460  void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)
461  {
462     CTimer::get("XIOS").resume();
463    if(!string_copy(domaingroup_hdl->name.getValue(),name , name_size))
464      ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short");
465     CTimer::get("XIOS").suspend();
466  }
467 
468  bool cxios_is_defined_domaingroup_name(domaingroup_Ptr domaingroup_hdl )
469  {
470     CTimer::get("XIOS").resume();
471    return !domaingroup_hdl->name.isEmpty();
472     CTimer::get("XIOS").suspend();
473  }
474 
475 
476 
477  void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni)
478  {
479     CTimer::get("XIOS").resume();
480    domaingroup_hdl->ni.setValue(ni);
481    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni);
482     CTimer::get("XIOS").suspend();
483  }
484 
485  void cxios_get_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int* ni)
486  {
487    *ni = domaingroup_hdl->ni.getValue();
488  }
489 
490  bool cxios_is_defined_domaingroup_ni(domaingroup_Ptr domaingroup_hdl )
491  {
492     CTimer::get("XIOS").resume();
493    return !domaingroup_hdl->ni.isEmpty();
494     CTimer::get("XIOS").suspend();
495  }
496 
497 
498 
499  void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo)
500  {
501     CTimer::get("XIOS").resume();
502    domaingroup_hdl->ni_glo.setValue(ni_glo);
503    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni_glo);
504     CTimer::get("XIOS").suspend();
505  }
506 
507  void cxios_get_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int* ni_glo)
508  {
509    *ni_glo = domaingroup_hdl->ni_glo.getValue();
510  }
511 
512  bool cxios_is_defined_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl )
513  {
514     CTimer::get("XIOS").resume();
515    return !domaingroup_hdl->ni_glo.isEmpty();
516     CTimer::get("XIOS").suspend();
517  }
518 
519 
520 
521  void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj)
522  {
523     CTimer::get("XIOS").resume();
524    domaingroup_hdl->nj.setValue(nj);
525    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj);
526     CTimer::get("XIOS").suspend();
527  }
528 
529  void cxios_get_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int* nj)
530  {
531    *nj = domaingroup_hdl->nj.getValue();
532  }
533 
534  bool cxios_is_defined_domaingroup_nj(domaingroup_Ptr domaingroup_hdl )
535  {
536     CTimer::get("XIOS").resume();
537    return !domaingroup_hdl->nj.isEmpty();
538     CTimer::get("XIOS").suspend();
539  }
540 
541 
542 
543  void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo)
544  {
545     CTimer::get("XIOS").resume();
546    domaingroup_hdl->nj_glo.setValue(nj_glo);
547    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj_glo);
548     CTimer::get("XIOS").suspend();
549  }
550 
551  void cxios_get_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int* nj_glo)
552  {
553    *nj_glo = domaingroup_hdl->nj_glo.getValue();
554  }
555 
556  bool cxios_is_defined_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl )
557  {
558     CTimer::get("XIOS").resume();
559    return !domaingroup_hdl->nj_glo.isEmpty();
560     CTimer::get("XIOS").suspend();
561  }
562 
563 
564 
565  void cxios_set_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, const char * standard_name, int standard_name_size)
566  {
567    std::string standard_name_str;
568    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
569     CTimer::get("XIOS").resume();
570    domaingroup_hdl->standard_name.setValue(standard_name_str);
571    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->standard_name);
572     CTimer::get("XIOS").suspend();
573  }
574 
575  void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)
576  {
577     CTimer::get("XIOS").resume();
578    if(!string_copy(domaingroup_hdl->standard_name.getValue(),standard_name , standard_name_size))
579      ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
580     CTimer::get("XIOS").suspend();
581  }
582 
583  bool cxios_is_defined_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl )
584  {
585     CTimer::get("XIOS").resume();
586    return !domaingroup_hdl->standard_name.isEmpty();
587     CTimer::get("XIOS").suspend();
588  }
589 
590 
591 
592  void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin)
593  {
594     CTimer::get("XIOS").resume();
595    domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin);
596    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin);
597     CTimer::get("XIOS").suspend();
598  }
599 
600  void cxios_get_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin)
601  {
602    *zoom_ibegin = domaingroup_hdl->zoom_ibegin.getValue();
603  }
604 
605  bool cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl )
606  {
607     CTimer::get("XIOS").resume();
608    return !domaingroup_hdl->zoom_ibegin.isEmpty();
609     CTimer::get("XIOS").suspend();
610  }
611 
612 
613 
614  void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc)
615  {
616     CTimer::get("XIOS").resume();
617    domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
618    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin_loc);
619     CTimer::get("XIOS").suspend();
620  }
621 
622  void cxios_get_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin_loc)
623  {
624    *zoom_ibegin_loc = domaingroup_hdl->zoom_ibegin_loc.getValue();
625  }
626 
627  bool cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl )
628  {
629     CTimer::get("XIOS").resume();
630    return !domaingroup_hdl->zoom_ibegin_loc.isEmpty();
631     CTimer::get("XIOS").suspend();
632  }
633 
634 
635 
636  void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin)
637  {
638     CTimer::get("XIOS").resume();
639    domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin);
640    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin);
641     CTimer::get("XIOS").suspend();
642  }
643 
644  void cxios_get_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin)
645  {
646    *zoom_jbegin = domaingroup_hdl->zoom_jbegin.getValue();
647  }
648 
649  bool cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl )
650  {
651     CTimer::get("XIOS").resume();
652    return !domaingroup_hdl->zoom_jbegin.isEmpty();
653     CTimer::get("XIOS").suspend();
654  }
655 
656 
657 
658  void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc)
659  {
660     CTimer::get("XIOS").resume();
661    domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
662    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin_loc);
663     CTimer::get("XIOS").suspend();
664  }
665 
666  void cxios_get_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin_loc)
667  {
668    *zoom_jbegin_loc = domaingroup_hdl->zoom_jbegin_loc.getValue();
669  }
670 
671  bool cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl )
672  {
673     CTimer::get("XIOS").resume();
674    return !domaingroup_hdl->zoom_jbegin_loc.isEmpty();
675     CTimer::get("XIOS").suspend();
676  }
677 
678 
679 
680  void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni)
681  {
682     CTimer::get("XIOS").resume();
683    domaingroup_hdl->zoom_ni.setValue(zoom_ni);
684    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni);
685     CTimer::get("XIOS").suspend();
686  }
687 
688  void cxios_get_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int* zoom_ni)
689  {
690    *zoom_ni = domaingroup_hdl->zoom_ni.getValue();
691  }
692 
693  bool cxios_is_defined_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl )
694  {
695     CTimer::get("XIOS").resume();
696    return !domaingroup_hdl->zoom_ni.isEmpty();
697     CTimer::get("XIOS").suspend();
698  }
699 
700 
701 
702  void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc)
703  {
704     CTimer::get("XIOS").resume();
705    domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
706    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni_loc);
707     CTimer::get("XIOS").suspend();
708  }
709 
710  void cxios_get_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ni_loc)
711  {
712    *zoom_ni_loc = domaingroup_hdl->zoom_ni_loc.getValue();
713  }
714 
715  bool cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl )
716  {
717     CTimer::get("XIOS").resume();
718    return !domaingroup_hdl->zoom_ni_loc.isEmpty();
719     CTimer::get("XIOS").suspend();
720  }
721 
722 
723 
724  void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj)
725  {
726     CTimer::get("XIOS").resume();
727    domaingroup_hdl->zoom_nj.setValue(zoom_nj);
728    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj);
729     CTimer::get("XIOS").suspend();
730  }
731 
732  void cxios_get_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int* zoom_nj)
733  {
734    *zoom_nj = domaingroup_hdl->zoom_nj.getValue();
735  }
736 
737  bool cxios_is_defined_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl )
738  {
739     CTimer::get("XIOS").resume();
740    return !domaingroup_hdl->zoom_nj.isEmpty();
741     CTimer::get("XIOS").suspend();
742  }
743 
744 
745 
746  void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc)
747  {
748     CTimer::get("XIOS").resume();
749    domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
750    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj_loc);
751     CTimer::get("XIOS").suspend();
752  }
753 
754  void cxios_get_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_nj_loc)
755  {
756    *zoom_nj_loc = domaingroup_hdl->zoom_nj_loc.getValue();
757  }
758 
759  bool cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl )
760  {
761     CTimer::get("XIOS").resume();
762    return !domaingroup_hdl->zoom_nj_loc.isEmpty();
763     CTimer::get("XIOS").suspend();
764  }
765 
766 
767 
768 
769}
Note: See TracBrowser for help on using the repository browser.