source: XIOS/branchs/xios-1.0/src/interface/c_attr/icdomaingroup_attr.cpp @ 581

Last change on this file since 581 was 581, checked in by rlacroix, 6 years ago

Fix the Fortran interface generation to avoid generating dead code that caused a timer not to be stopped.

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:eol-style set to native
File size: 31.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_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2)
20  {
21    CTimer::get("XIOS").resume();
22    CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ;
23    domaingroup_hdl->bounds_lat.reference(tmp.copy());
24    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->bounds_lat);
25     CTimer::get("XIOS").suspend();
26  }
27 
28  void cxios_get_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2)
29  {
30    CTimer::get("XIOS").resume();
31    CArray<double,2> tmp(bounds_lat,shape(extent1,extent2),neverDeleteData) ;
32    tmp=domaingroup_hdl->bounds_lat.getInheritedValue() ;
33     CTimer::get("XIOS").suspend();
34  }
35 
36  bool cxios_is_defined_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl )
37  {
38    CTimer::get("XIOS").resume();
39    bool isDefined = domaingroup_hdl->bounds_lat.hasInheritedValue();
40    CTimer::get("XIOS").suspend();
41    return isDefined;
42  }
43 
44 
45 
46  void cxios_set_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2)
47  {
48    CTimer::get("XIOS").resume();
49    CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ;
50    domaingroup_hdl->bounds_lon.reference(tmp.copy());
51    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->bounds_lon);
52     CTimer::get("XIOS").suspend();
53  }
54 
55  void cxios_get_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2)
56  {
57    CTimer::get("XIOS").resume();
58    CArray<double,2> tmp(bounds_lon,shape(extent1,extent2),neverDeleteData) ;
59    tmp=domaingroup_hdl->bounds_lon.getInheritedValue() ;
60     CTimer::get("XIOS").suspend();
61  }
62 
63  bool cxios_is_defined_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl )
64  {
65    CTimer::get("XIOS").resume();
66    bool isDefined = domaingroup_hdl->bounds_lon.hasInheritedValue();
67    CTimer::get("XIOS").suspend();
68    return isDefined;
69  }
70 
71 
72 
73  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim)
74  {
75     CTimer::get("XIOS").resume();
76    domaingroup_hdl->data_dim.setValue(data_dim);
77    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_dim);
78     CTimer::get("XIOS").suspend();
79  }
80 
81  void cxios_get_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int* data_dim)
82  {
83    *data_dim = domaingroup_hdl->data_dim.getInheritedValue();
84  }
85 
86  bool cxios_is_defined_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl )
87  {
88    CTimer::get("XIOS").resume();
89    bool isDefined = domaingroup_hdl->data_dim.hasInheritedValue();
90    CTimer::get("XIOS").suspend();
91    return isDefined;
92  }
93 
94 
95 
96  void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
97  {
98    CTimer::get("XIOS").resume();
99    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ;
100    domaingroup_hdl->data_i_index.reference(tmp.copy());
101    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_i_index);
102     CTimer::get("XIOS").suspend();
103  }
104 
105  void cxios_get_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
106  {
107    CTimer::get("XIOS").resume();
108    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ;
109    tmp=domaingroup_hdl->data_i_index.getInheritedValue() ;
110     CTimer::get("XIOS").suspend();
111  }
112 
113  bool cxios_is_defined_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl )
114  {
115    CTimer::get("XIOS").resume();
116    bool isDefined = domaingroup_hdl->data_i_index.hasInheritedValue();
117    CTimer::get("XIOS").suspend();
118    return isDefined;
119  }
120 
121 
122 
123  void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin)
124  {
125     CTimer::get("XIOS").resume();
126    domaingroup_hdl->data_ibegin.setValue(data_ibegin);
127    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ibegin);
128     CTimer::get("XIOS").suspend();
129  }
130 
131  void cxios_get_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* data_ibegin)
132  {
133    *data_ibegin = domaingroup_hdl->data_ibegin.getInheritedValue();
134  }
135 
136  bool cxios_is_defined_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl )
137  {
138    CTimer::get("XIOS").resume();
139    bool isDefined = domaingroup_hdl->data_ibegin.hasInheritedValue();
140    CTimer::get("XIOS").suspend();
141    return isDefined;
142  }
143 
144 
145 
146  void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)
147  {
148    CTimer::get("XIOS").resume();
149    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ;
150    domaingroup_hdl->data_j_index.reference(tmp.copy());
151    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_j_index);
152     CTimer::get("XIOS").suspend();
153  }
154 
155  void cxios_get_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)
156  {
157    CTimer::get("XIOS").resume();
158    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ;
159    tmp=domaingroup_hdl->data_j_index.getInheritedValue() ;
160     CTimer::get("XIOS").suspend();
161  }
162 
163  bool cxios_is_defined_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl )
164  {
165    CTimer::get("XIOS").resume();
166    bool isDefined = domaingroup_hdl->data_j_index.hasInheritedValue();
167    CTimer::get("XIOS").suspend();
168    return isDefined;
169  }
170 
171 
172 
173  void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin)
174  {
175     CTimer::get("XIOS").resume();
176    domaingroup_hdl->data_jbegin.setValue(data_jbegin);
177    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_jbegin);
178     CTimer::get("XIOS").suspend();
179  }
180 
181  void cxios_get_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* data_jbegin)
182  {
183    *data_jbegin = domaingroup_hdl->data_jbegin.getInheritedValue();
184  }
185 
186  bool cxios_is_defined_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl )
187  {
188    CTimer::get("XIOS").resume();
189    bool isDefined = domaingroup_hdl->data_jbegin.hasInheritedValue();
190    CTimer::get("XIOS").suspend();
191    return isDefined;
192  }
193 
194 
195 
196  void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index)
197  {
198     CTimer::get("XIOS").resume();
199    domaingroup_hdl->data_n_index.setValue(data_n_index);
200    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_n_index);
201     CTimer::get("XIOS").suspend();
202  }
203 
204  void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index)
205  {
206    *data_n_index = domaingroup_hdl->data_n_index.getInheritedValue();
207  }
208 
209  bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl )
210  {
211    CTimer::get("XIOS").resume();
212    bool isDefined = domaingroup_hdl->data_n_index.hasInheritedValue();
213    CTimer::get("XIOS").suspend();
214    return isDefined;
215  }
216 
217 
218 
219  void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni)
220  {
221     CTimer::get("XIOS").resume();
222    domaingroup_hdl->data_ni.setValue(data_ni);
223    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ni);
224     CTimer::get("XIOS").suspend();
225  }
226 
227  void cxios_get_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int* data_ni)
228  {
229    *data_ni = domaingroup_hdl->data_ni.getInheritedValue();
230  }
231 
232  bool cxios_is_defined_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl )
233  {
234    CTimer::get("XIOS").resume();
235    bool isDefined = domaingroup_hdl->data_ni.hasInheritedValue();
236    CTimer::get("XIOS").suspend();
237    return isDefined;
238  }
239 
240 
241 
242  void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj)
243  {
244     CTimer::get("XIOS").resume();
245    domaingroup_hdl->data_nj.setValue(data_nj);
246    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_nj);
247     CTimer::get("XIOS").suspend();
248  }
249 
250  void cxios_get_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int* data_nj)
251  {
252    *data_nj = domaingroup_hdl->data_nj.getInheritedValue();
253  }
254 
255  bool cxios_is_defined_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl )
256  {
257    CTimer::get("XIOS").resume();
258    bool isDefined = domaingroup_hdl->data_nj.hasInheritedValue();
259    CTimer::get("XIOS").suspend();
260    return isDefined;
261  }
262 
263 
264 
265  void cxios_set_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size)
266  {
267    std::string domain_group_ref_str;
268    if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
269     CTimer::get("XIOS").resume();
270    domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str);
271    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->domain_group_ref);
272     CTimer::get("XIOS").suspend();
273  }
274 
275  void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)
276  {
277     CTimer::get("XIOS").resume();
278    if(!string_copy(domaingroup_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size))
279      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");
280     CTimer::get("XIOS").suspend();
281  }
282 
283  bool cxios_is_defined_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl )
284  {
285    CTimer::get("XIOS").resume();
286    bool isDefined = domaingroup_hdl->domain_group_ref.hasInheritedValue();
287    CTimer::get("XIOS").suspend();
288    return isDefined;
289  }
290 
291 
292 
293  void cxios_set_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, const char * group_ref, int group_ref_size)
294  {
295    std::string group_ref_str;
296    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
297     CTimer::get("XIOS").resume();
298    domaingroup_hdl->group_ref.setValue(group_ref_str);
299    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->group_ref);
300     CTimer::get("XIOS").suspend();
301  }
302 
303  void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)
304  {
305     CTimer::get("XIOS").resume();
306    if(!string_copy(domaingroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size))
307      ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
308     CTimer::get("XIOS").suspend();
309  }
310 
311  bool cxios_is_defined_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl )
312  {
313    CTimer::get("XIOS").resume();
314    bool isDefined = domaingroup_hdl->group_ref.hasInheritedValue();
315    CTimer::get("XIOS").suspend();
316    return isDefined;
317  }
318 
319 
320 
321  void cxios_set_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl, int* i_index, int extent1, int extent2)
322  {
323    CTimer::get("XIOS").resume();
324    CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ;
325    domaingroup_hdl->i_index.reference(tmp.copy());
326    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->i_index);
327     CTimer::get("XIOS").suspend();
328  }
329 
330  void cxios_get_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl, int* i_index, int extent1, int extent2)
331  {
332    CTimer::get("XIOS").resume();
333    CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ;
334    tmp=domaingroup_hdl->i_index.getInheritedValue() ;
335     CTimer::get("XIOS").suspend();
336  }
337 
338  bool cxios_is_defined_domaingroup_i_index(domaingroup_Ptr domaingroup_hdl )
339  {
340    CTimer::get("XIOS").resume();
341    bool isDefined = domaingroup_hdl->i_index.hasInheritedValue();
342    CTimer::get("XIOS").suspend();
343    return isDefined;
344  }
345 
346 
347 
348  void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin)
349  {
350     CTimer::get("XIOS").resume();
351    domaingroup_hdl->ibegin.setValue(ibegin);
352    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ibegin);
353     CTimer::get("XIOS").suspend();
354  }
355 
356  void cxios_get_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int* ibegin)
357  {
358    *ibegin = domaingroup_hdl->ibegin.getInheritedValue();
359  }
360 
361  bool cxios_is_defined_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl )
362  {
363    CTimer::get("XIOS").resume();
364    bool isDefined = domaingroup_hdl->ibegin.hasInheritedValue();
365    CTimer::get("XIOS").suspend();
366    return isDefined;
367  }
368 
369 
370 
371  void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend)
372  {
373     CTimer::get("XIOS").resume();
374    domaingroup_hdl->iend.setValue(iend);
375    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->iend);
376     CTimer::get("XIOS").suspend();
377  }
378 
379  void cxios_get_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int* iend)
380  {
381    *iend = domaingroup_hdl->iend.getInheritedValue();
382  }
383 
384  bool cxios_is_defined_domaingroup_iend(domaingroup_Ptr domaingroup_hdl )
385  {
386    CTimer::get("XIOS").resume();
387    bool isDefined = domaingroup_hdl->iend.hasInheritedValue();
388    CTimer::get("XIOS").suspend();
389    return isDefined;
390  }
391 
392 
393 
394  void cxios_set_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl, int* j_index, int extent1, int extent2)
395  {
396    CTimer::get("XIOS").resume();
397    CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ;
398    domaingroup_hdl->j_index.reference(tmp.copy());
399    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->j_index);
400     CTimer::get("XIOS").suspend();
401  }
402 
403  void cxios_get_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl, int* j_index, int extent1, int extent2)
404  {
405    CTimer::get("XIOS").resume();
406    CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ;
407    tmp=domaingroup_hdl->j_index.getInheritedValue() ;
408     CTimer::get("XIOS").suspend();
409  }
410 
411  bool cxios_is_defined_domaingroup_j_index(domaingroup_Ptr domaingroup_hdl )
412  {
413    CTimer::get("XIOS").resume();
414    bool isDefined = domaingroup_hdl->j_index.hasInheritedValue();
415    CTimer::get("XIOS").suspend();
416    return isDefined;
417  }
418 
419 
420 
421  void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin)
422  {
423     CTimer::get("XIOS").resume();
424    domaingroup_hdl->jbegin.setValue(jbegin);
425    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jbegin);
426     CTimer::get("XIOS").suspend();
427  }
428 
429  void cxios_get_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int* jbegin)
430  {
431    *jbegin = domaingroup_hdl->jbegin.getInheritedValue();
432  }
433 
434  bool cxios_is_defined_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl )
435  {
436    CTimer::get("XIOS").resume();
437    bool isDefined = domaingroup_hdl->jbegin.hasInheritedValue();
438    CTimer::get("XIOS").suspend();
439    return isDefined;
440  }
441 
442 
443 
444  void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend)
445  {
446     CTimer::get("XIOS").resume();
447    domaingroup_hdl->jend.setValue(jend);
448    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jend);
449     CTimer::get("XIOS").suspend();
450  }
451 
452  void cxios_get_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int* jend)
453  {
454    *jend = domaingroup_hdl->jend.getInheritedValue();
455  }
456 
457  bool cxios_is_defined_domaingroup_jend(domaingroup_Ptr domaingroup_hdl )
458  {
459    CTimer::get("XIOS").resume();
460    bool isDefined = domaingroup_hdl->jend.hasInheritedValue();
461    CTimer::get("XIOS").suspend();
462    return isDefined;
463  }
464 
465 
466 
467  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
468  {
469    CTimer::get("XIOS").resume();
470    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
471    domaingroup_hdl->latvalue.reference(tmp.copy());
472    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->latvalue);
473     CTimer::get("XIOS").suspend();
474  }
475 
476  void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
477  {
478    CTimer::get("XIOS").resume();
479    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
480    tmp=domaingroup_hdl->latvalue.getInheritedValue() ;
481     CTimer::get("XIOS").suspend();
482  }
483 
484  bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl )
485  {
486    CTimer::get("XIOS").resume();
487    bool isDefined = domaingroup_hdl->latvalue.hasInheritedValue();
488    CTimer::get("XIOS").suspend();
489    return isDefined;
490  }
491 
492 
493 
494  void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size)
495  {
496    std::string long_name_str;
497    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
498     CTimer::get("XIOS").resume();
499    domaingroup_hdl->long_name.setValue(long_name_str);
500    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->long_name);
501     CTimer::get("XIOS").suspend();
502  }
503 
504  void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)
505  {
506     CTimer::get("XIOS").resume();
507    if(!string_copy(domaingroup_hdl->long_name.getInheritedValue(),long_name , long_name_size))
508      ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
509     CTimer::get("XIOS").suspend();
510  }
511 
512  bool cxios_is_defined_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl )
513  {
514    CTimer::get("XIOS").resume();
515    bool isDefined = domaingroup_hdl->long_name.hasInheritedValue();
516    CTimer::get("XIOS").suspend();
517    return isDefined;
518  }
519 
520 
521 
522  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
523  {
524    CTimer::get("XIOS").resume();
525    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
526    domaingroup_hdl->lonvalue.reference(tmp.copy());
527    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->lonvalue);
528     CTimer::get("XIOS").suspend();
529  }
530 
531  void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
532  {
533    CTimer::get("XIOS").resume();
534    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
535    tmp=domaingroup_hdl->lonvalue.getInheritedValue() ;
536     CTimer::get("XIOS").suspend();
537  }
538 
539  bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl )
540  {
541    CTimer::get("XIOS").resume();
542    bool isDefined = domaingroup_hdl->lonvalue.hasInheritedValue();
543    CTimer::get("XIOS").suspend();
544    return isDefined;
545  }
546 
547 
548 
549  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
550  {
551    CTimer::get("XIOS").resume();
552    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
553    domaingroup_hdl->mask.reference(tmp.copy());
554    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->mask);
555     CTimer::get("XIOS").suspend();
556  }
557 
558  void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
559  {
560    CTimer::get("XIOS").resume();
561    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
562    tmp=domaingroup_hdl->mask.getInheritedValue() ;
563     CTimer::get("XIOS").suspend();
564  }
565 
566  bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl )
567  {
568    CTimer::get("XIOS").resume();
569    bool isDefined = domaingroup_hdl->mask.hasInheritedValue();
570    CTimer::get("XIOS").suspend();
571    return isDefined;
572  }
573 
574 
575 
576  void cxios_set_domaingroup_name(domaingroup_Ptr domaingroup_hdl, const char * name, int name_size)
577  {
578    std::string name_str;
579    if(!cstr2string(name, name_size, name_str)) return;
580     CTimer::get("XIOS").resume();
581    domaingroup_hdl->name.setValue(name_str);
582    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->name);
583     CTimer::get("XIOS").suspend();
584  }
585 
586  void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)
587  {
588     CTimer::get("XIOS").resume();
589    if(!string_copy(domaingroup_hdl->name.getInheritedValue(),name , name_size))
590      ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short");
591     CTimer::get("XIOS").suspend();
592  }
593 
594  bool cxios_is_defined_domaingroup_name(domaingroup_Ptr domaingroup_hdl )
595  {
596    CTimer::get("XIOS").resume();
597    bool isDefined = domaingroup_hdl->name.hasInheritedValue();
598    CTimer::get("XIOS").suspend();
599    return isDefined;
600  }
601 
602 
603 
604  void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni)
605  {
606     CTimer::get("XIOS").resume();
607    domaingroup_hdl->ni.setValue(ni);
608    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni);
609     CTimer::get("XIOS").suspend();
610  }
611 
612  void cxios_get_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int* ni)
613  {
614    *ni = domaingroup_hdl->ni.getInheritedValue();
615  }
616 
617  bool cxios_is_defined_domaingroup_ni(domaingroup_Ptr domaingroup_hdl )
618  {
619    CTimer::get("XIOS").resume();
620    bool isDefined = domaingroup_hdl->ni.hasInheritedValue();
621    CTimer::get("XIOS").suspend();
622    return isDefined;
623  }
624 
625 
626 
627  void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo)
628  {
629     CTimer::get("XIOS").resume();
630    domaingroup_hdl->ni_glo.setValue(ni_glo);
631    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni_glo);
632     CTimer::get("XIOS").suspend();
633  }
634 
635  void cxios_get_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int* ni_glo)
636  {
637    *ni_glo = domaingroup_hdl->ni_glo.getInheritedValue();
638  }
639 
640  bool cxios_is_defined_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl )
641  {
642    CTimer::get("XIOS").resume();
643    bool isDefined = domaingroup_hdl->ni_glo.hasInheritedValue();
644    CTimer::get("XIOS").suspend();
645    return isDefined;
646  }
647 
648 
649 
650  void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj)
651  {
652     CTimer::get("XIOS").resume();
653    domaingroup_hdl->nj.setValue(nj);
654    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj);
655     CTimer::get("XIOS").suspend();
656  }
657 
658  void cxios_get_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int* nj)
659  {
660    *nj = domaingroup_hdl->nj.getInheritedValue();
661  }
662 
663  bool cxios_is_defined_domaingroup_nj(domaingroup_Ptr domaingroup_hdl )
664  {
665    CTimer::get("XIOS").resume();
666    bool isDefined = domaingroup_hdl->nj.hasInheritedValue();
667    CTimer::get("XIOS").suspend();
668    return isDefined;
669  }
670 
671 
672 
673  void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo)
674  {
675     CTimer::get("XIOS").resume();
676    domaingroup_hdl->nj_glo.setValue(nj_glo);
677    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj_glo);
678     CTimer::get("XIOS").suspend();
679  }
680 
681  void cxios_get_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int* nj_glo)
682  {
683    *nj_glo = domaingroup_hdl->nj_glo.getInheritedValue();
684  }
685 
686  bool cxios_is_defined_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl )
687  {
688    CTimer::get("XIOS").resume();
689    bool isDefined = domaingroup_hdl->nj_glo.hasInheritedValue();
690    CTimer::get("XIOS").suspend();
691    return isDefined;
692  }
693 
694 
695 
696  void cxios_set_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl, int nvertex)
697  {
698     CTimer::get("XIOS").resume();
699    domaingroup_hdl->nvertex.setValue(nvertex);
700    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nvertex);
701     CTimer::get("XIOS").suspend();
702  }
703 
704  void cxios_get_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl, int* nvertex)
705  {
706    *nvertex = domaingroup_hdl->nvertex.getInheritedValue();
707  }
708 
709  bool cxios_is_defined_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl )
710  {
711    CTimer::get("XIOS").resume();
712    bool isDefined = domaingroup_hdl->nvertex.hasInheritedValue();
713    CTimer::get("XIOS").suspend();
714    return isDefined;
715  }
716 
717 
718 
719  void cxios_set_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, const char * standard_name, int standard_name_size)
720  {
721    std::string standard_name_str;
722    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
723     CTimer::get("XIOS").resume();
724    domaingroup_hdl->standard_name.setValue(standard_name_str);
725    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->standard_name);
726     CTimer::get("XIOS").suspend();
727  }
728 
729  void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)
730  {
731     CTimer::get("XIOS").resume();
732    if(!string_copy(domaingroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
733      ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
734     CTimer::get("XIOS").suspend();
735  }
736 
737  bool cxios_is_defined_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl )
738  {
739    CTimer::get("XIOS").resume();
740    bool isDefined = domaingroup_hdl->standard_name.hasInheritedValue();
741    CTimer::get("XIOS").suspend();
742    return isDefined;
743  }
744 
745 
746 
747  void cxios_set_domaingroup_type(domaingroup_Ptr domaingroup_hdl, const char * type, int type_size)
748  {
749    std::string type_str;
750    if(!cstr2string(type, type_size, type_str)) return;
751     CTimer::get("XIOS").resume();
752    domaingroup_hdl->type.fromString(type_str);
753    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->type);
754     CTimer::get("XIOS").suspend();
755  }
756 
757  void cxios_get_domaingroup_type(domaingroup_Ptr domaingroup_hdl, char * type, int type_size)
758  {
759     CTimer::get("XIOS").resume();
760    if(!string_copy(domaingroup_hdl->type.getInheritedStringValue(),type , type_size))
761      ERROR("void cxios_get_domaingroup_type(domaingroup_Ptr domaingroup_hdl, char * type, int type_size)", <<"Input string is to short");
762     CTimer::get("XIOS").suspend();
763  }
764 
765  bool cxios_is_defined_domaingroup_type(domaingroup_Ptr domaingroup_hdl )
766  {
767    CTimer::get("XIOS").resume();
768    bool isDefined = domaingroup_hdl->type.hasInheritedValue();
769    CTimer::get("XIOS").suspend();
770    return isDefined;
771  }
772 
773 
774 
775  void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin)
776  {
777     CTimer::get("XIOS").resume();
778    domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin);
779    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin);
780     CTimer::get("XIOS").suspend();
781  }
782 
783  void cxios_get_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin)
784  {
785    *zoom_ibegin = domaingroup_hdl->zoom_ibegin.getInheritedValue();
786  }
787 
788  bool cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl )
789  {
790    CTimer::get("XIOS").resume();
791    bool isDefined = domaingroup_hdl->zoom_ibegin.hasInheritedValue();
792    CTimer::get("XIOS").suspend();
793    return isDefined;
794  }
795 
796 
797 
798  void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc)
799  {
800     CTimer::get("XIOS").resume();
801    domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
802    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin_loc);
803     CTimer::get("XIOS").suspend();
804  }
805 
806  void cxios_get_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin_loc)
807  {
808    *zoom_ibegin_loc = domaingroup_hdl->zoom_ibegin_loc.getInheritedValue();
809  }
810 
811  bool cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl )
812  {
813    CTimer::get("XIOS").resume();
814    bool isDefined = domaingroup_hdl->zoom_ibegin_loc.hasInheritedValue();
815    CTimer::get("XIOS").suspend();
816    return isDefined;
817  }
818 
819 
820 
821  void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin)
822  {
823     CTimer::get("XIOS").resume();
824    domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin);
825    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin);
826     CTimer::get("XIOS").suspend();
827  }
828 
829  void cxios_get_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin)
830  {
831    *zoom_jbegin = domaingroup_hdl->zoom_jbegin.getInheritedValue();
832  }
833 
834  bool cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl )
835  {
836    CTimer::get("XIOS").resume();
837    bool isDefined = domaingroup_hdl->zoom_jbegin.hasInheritedValue();
838    CTimer::get("XIOS").suspend();
839    return isDefined;
840  }
841 
842 
843 
844  void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc)
845  {
846     CTimer::get("XIOS").resume();
847    domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
848    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin_loc);
849     CTimer::get("XIOS").suspend();
850  }
851 
852  void cxios_get_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin_loc)
853  {
854    *zoom_jbegin_loc = domaingroup_hdl->zoom_jbegin_loc.getInheritedValue();
855  }
856 
857  bool cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl )
858  {
859    CTimer::get("XIOS").resume();
860    bool isDefined = domaingroup_hdl->zoom_jbegin_loc.hasInheritedValue();
861    CTimer::get("XIOS").suspend();
862    return isDefined;
863  }
864 
865 
866 
867  void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni)
868  {
869     CTimer::get("XIOS").resume();
870    domaingroup_hdl->zoom_ni.setValue(zoom_ni);
871    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni);
872     CTimer::get("XIOS").suspend();
873  }
874 
875  void cxios_get_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int* zoom_ni)
876  {
877    *zoom_ni = domaingroup_hdl->zoom_ni.getInheritedValue();
878  }
879 
880  bool cxios_is_defined_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl )
881  {
882    CTimer::get("XIOS").resume();
883    bool isDefined = domaingroup_hdl->zoom_ni.hasInheritedValue();
884    CTimer::get("XIOS").suspend();
885    return isDefined;
886  }
887 
888 
889 
890  void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc)
891  {
892     CTimer::get("XIOS").resume();
893    domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
894    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni_loc);
895     CTimer::get("XIOS").suspend();
896  }
897 
898  void cxios_get_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ni_loc)
899  {
900    *zoom_ni_loc = domaingroup_hdl->zoom_ni_loc.getInheritedValue();
901  }
902 
903  bool cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl )
904  {
905    CTimer::get("XIOS").resume();
906    bool isDefined = domaingroup_hdl->zoom_ni_loc.hasInheritedValue();
907    CTimer::get("XIOS").suspend();
908    return isDefined;
909  }
910 
911 
912 
913  void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj)
914  {
915     CTimer::get("XIOS").resume();
916    domaingroup_hdl->zoom_nj.setValue(zoom_nj);
917    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj);
918     CTimer::get("XIOS").suspend();
919  }
920 
921  void cxios_get_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int* zoom_nj)
922  {
923    *zoom_nj = domaingroup_hdl->zoom_nj.getInheritedValue();
924  }
925 
926  bool cxios_is_defined_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl )
927  {
928    CTimer::get("XIOS").resume();
929    bool isDefined = domaingroup_hdl->zoom_nj.hasInheritedValue();
930    CTimer::get("XIOS").suspend();
931    return isDefined;
932  }
933 
934 
935 
936  void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc)
937  {
938     CTimer::get("XIOS").resume();
939    domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
940    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj_loc);
941     CTimer::get("XIOS").suspend();
942  }
943 
944  void cxios_get_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_nj_loc)
945  {
946    *zoom_nj_loc = domaingroup_hdl->zoom_nj_loc.getInheritedValue();
947  }
948 
949  bool cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl )
950  {
951    CTimer::get("XIOS").resume();
952    bool isDefined = domaingroup_hdl->zoom_nj_loc.hasInheritedValue();
953    CTimer::get("XIOS").suspend();
954    return isDefined;
955  }
956 
957 
958 
959 
960}
Note: See TracBrowser for help on using the repository browser.