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

Last change on this file since 509 was 509, checked in by mhnguyen, 9 years ago

Implementing buffer size auto-detection for mode client -server

+) Process xml tree in client side then send all the information to server
+) Only information enabled fields in enabled files are sent to server
+) Some important change in structure of code which must be refactored

Test
+) On Curie
+) Only mode client-server
+) Passed for all tests

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