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

Last change on this file since 501 was 501, checked in by ymipsl, 7 years ago

Add licence copyright to all file ond directory src using the command :
svn propset -R copyright -F header_licence src

XIOS is now officialy under CeCILL licence

YM

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