source: XIOS/trunk/src/interface/c_attr/icdomain_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: 26.6 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                   *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include "xmlioserver.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.hpp"
12#include "timer.hpp"
13#include "node_type.hpp"
14
15extern "C"
16{
17  typedef xios::CDomain*  domain_Ptr;
18 
19  void cxios_set_domain_bounds_lat(domain_Ptr domain_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    domain_hdl->bounds_lat.reference(tmp.copy());
24    domain_hdl->sendAttributToServer(domain_hdl->bounds_lat);
25     CTimer::get("XIOS").suspend();
26  }
27 
28  void cxios_get_domain_bounds_lat(domain_Ptr domain_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=domain_hdl->bounds_lat.getInheritedValue() ;
33     CTimer::get("XIOS").suspend();
34  }
35 
36  bool cxios_is_defined_domain_bounds_lat(domain_Ptr domain_hdl )
37  {
38     CTimer::get("XIOS").resume();
39    return domain_hdl->bounds_lat.hasInheritedValue();
40     CTimer::get("XIOS").suspend();
41  }
42 
43 
44 
45  void cxios_set_domain_bounds_lon(domain_Ptr domain_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    domain_hdl->bounds_lon.reference(tmp.copy());
50    domain_hdl->sendAttributToServer(domain_hdl->bounds_lon);
51     CTimer::get("XIOS").suspend();
52  }
53 
54  void cxios_get_domain_bounds_lon(domain_Ptr domain_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=domain_hdl->bounds_lon.getInheritedValue() ;
59     CTimer::get("XIOS").suspend();
60  }
61 
62  bool cxios_is_defined_domain_bounds_lon(domain_Ptr domain_hdl )
63  {
64     CTimer::get("XIOS").resume();
65    return domain_hdl->bounds_lon.hasInheritedValue();
66     CTimer::get("XIOS").suspend();
67  }
68 
69 
70 
71  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
72  {
73     CTimer::get("XIOS").resume();
74    domain_hdl->data_dim.setValue(data_dim);
75    domain_hdl->sendAttributToServer(domain_hdl->data_dim);
76     CTimer::get("XIOS").suspend();
77  }
78 
79  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim)
80  {
81    *data_dim = domain_hdl->data_dim.getInheritedValue();
82  }
83 
84  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl )
85  {
86     CTimer::get("XIOS").resume();
87    return domain_hdl->data_dim.hasInheritedValue();
88     CTimer::get("XIOS").suspend();
89  }
90 
91 
92 
93  void cxios_set_domain_data_i_index(domain_Ptr domain_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    domain_hdl->data_i_index.reference(tmp.copy());
98    domain_hdl->sendAttributToServer(domain_hdl->data_i_index);
99     CTimer::get("XIOS").suspend();
100  }
101 
102  void cxios_get_domain_data_i_index(domain_Ptr domain_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=domain_hdl->data_i_index.getInheritedValue() ;
107     CTimer::get("XIOS").suspend();
108  }
109 
110  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl )
111  {
112     CTimer::get("XIOS").resume();
113    return domain_hdl->data_i_index.hasInheritedValue();
114     CTimer::get("XIOS").suspend();
115  }
116 
117 
118 
119  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
120  {
121     CTimer::get("XIOS").resume();
122    domain_hdl->data_ibegin.setValue(data_ibegin);
123    domain_hdl->sendAttributToServer(domain_hdl->data_ibegin);
124     CTimer::get("XIOS").suspend();
125  }
126 
127  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin)
128  {
129    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue();
130  }
131 
132  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl )
133  {
134     CTimer::get("XIOS").resume();
135    return domain_hdl->data_ibegin.hasInheritedValue();
136     CTimer::get("XIOS").suspend();
137  }
138 
139 
140 
141  void cxios_set_domain_data_j_index(domain_Ptr domain_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    domain_hdl->data_j_index.reference(tmp.copy());
146    domain_hdl->sendAttributToServer(domain_hdl->data_j_index);
147     CTimer::get("XIOS").suspend();
148  }
149 
150  void cxios_get_domain_data_j_index(domain_Ptr domain_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=domain_hdl->data_j_index.getInheritedValue() ;
155     CTimer::get("XIOS").suspend();
156  }
157 
158  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl )
159  {
160     CTimer::get("XIOS").resume();
161    return domain_hdl->data_j_index.hasInheritedValue();
162     CTimer::get("XIOS").suspend();
163  }
164 
165 
166 
167  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
168  {
169     CTimer::get("XIOS").resume();
170    domain_hdl->data_jbegin.setValue(data_jbegin);
171    domain_hdl->sendAttributToServer(domain_hdl->data_jbegin);
172     CTimer::get("XIOS").suspend();
173  }
174 
175  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin)
176  {
177    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue();
178  }
179 
180  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl )
181  {
182     CTimer::get("XIOS").resume();
183    return domain_hdl->data_jbegin.hasInheritedValue();
184     CTimer::get("XIOS").suspend();
185  }
186 
187 
188 
189  void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index)
190  {
191     CTimer::get("XIOS").resume();
192    domain_hdl->data_n_index.setValue(data_n_index);
193    domain_hdl->sendAttributToServer(domain_hdl->data_n_index);
194     CTimer::get("XIOS").suspend();
195  }
196 
197  void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index)
198  {
199    *data_n_index = domain_hdl->data_n_index.getInheritedValue();
200  }
201 
202  bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl )
203  {
204     CTimer::get("XIOS").resume();
205    return domain_hdl->data_n_index.hasInheritedValue();
206     CTimer::get("XIOS").suspend();
207  }
208 
209 
210 
211  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
212  {
213     CTimer::get("XIOS").resume();
214    domain_hdl->data_ni.setValue(data_ni);
215    domain_hdl->sendAttributToServer(domain_hdl->data_ni);
216     CTimer::get("XIOS").suspend();
217  }
218 
219  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni)
220  {
221    *data_ni = domain_hdl->data_ni.getInheritedValue();
222  }
223 
224  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl )
225  {
226     CTimer::get("XIOS").resume();
227    return domain_hdl->data_ni.hasInheritedValue();
228     CTimer::get("XIOS").suspend();
229  }
230 
231 
232 
233  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
234  {
235     CTimer::get("XIOS").resume();
236    domain_hdl->data_nj.setValue(data_nj);
237    domain_hdl->sendAttributToServer(domain_hdl->data_nj);
238     CTimer::get("XIOS").suspend();
239  }
240 
241  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj)
242  {
243    *data_nj = domain_hdl->data_nj.getInheritedValue();
244  }
245 
246  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl )
247  {
248     CTimer::get("XIOS").resume();
249    return domain_hdl->data_nj.hasInheritedValue();
250     CTimer::get("XIOS").suspend();
251  }
252 
253 
254 
255  void cxios_set_domain_domain_group_ref(domain_Ptr domain_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    domain_hdl->domain_group_ref.setValue(domain_group_ref_str);
261    domain_hdl->sendAttributToServer(domain_hdl->domain_group_ref);
262     CTimer::get("XIOS").suspend();
263  }
264 
265  void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)
266  {
267     CTimer::get("XIOS").resume();
268    if(!string_copy(domain_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size))
269      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short");
270     CTimer::get("XIOS").suspend();
271  }
272 
273  bool cxios_is_defined_domain_domain_group_ref(domain_Ptr domain_hdl )
274  {
275     CTimer::get("XIOS").resume();
276    return domain_hdl->domain_group_ref.hasInheritedValue();
277     CTimer::get("XIOS").suspend();
278  }
279 
280 
281 
282  void cxios_set_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1, int extent2)
283  {
284    CTimer::get("XIOS").resume();
285    CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ;
286    domain_hdl->i_index.reference(tmp.copy());
287    domain_hdl->sendAttributToServer(domain_hdl->i_index);
288     CTimer::get("XIOS").suspend();
289  }
290 
291  void cxios_get_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1, int extent2)
292  {
293    CTimer::get("XIOS").resume();
294    CArray<int,2> tmp(i_index,shape(extent1,extent2),neverDeleteData) ;
295    tmp=domain_hdl->i_index.getInheritedValue() ;
296     CTimer::get("XIOS").suspend();
297  }
298 
299  bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl )
300  {
301     CTimer::get("XIOS").resume();
302    return domain_hdl->i_index.hasInheritedValue();
303     CTimer::get("XIOS").suspend();
304  }
305 
306 
307 
308  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
309  {
310     CTimer::get("XIOS").resume();
311    domain_hdl->ibegin.setValue(ibegin);
312    domain_hdl->sendAttributToServer(domain_hdl->ibegin);
313     CTimer::get("XIOS").suspend();
314  }
315 
316  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin)
317  {
318    *ibegin = domain_hdl->ibegin.getInheritedValue();
319  }
320 
321  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl )
322  {
323     CTimer::get("XIOS").resume();
324    return domain_hdl->ibegin.hasInheritedValue();
325     CTimer::get("XIOS").suspend();
326  }
327 
328 
329 
330  void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend)
331  {
332     CTimer::get("XIOS").resume();
333    domain_hdl->iend.setValue(iend);
334    domain_hdl->sendAttributToServer(domain_hdl->iend);
335     CTimer::get("XIOS").suspend();
336  }
337 
338  void cxios_get_domain_iend(domain_Ptr domain_hdl, int* iend)
339  {
340    *iend = domain_hdl->iend.getInheritedValue();
341  }
342 
343  bool cxios_is_defined_domain_iend(domain_Ptr domain_hdl )
344  {
345     CTimer::get("XIOS").resume();
346    return domain_hdl->iend.hasInheritedValue();
347     CTimer::get("XIOS").suspend();
348  }
349 
350 
351 
352  void cxios_set_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1, int extent2)
353  {
354    CTimer::get("XIOS").resume();
355    CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ;
356    domain_hdl->j_index.reference(tmp.copy());
357    domain_hdl->sendAttributToServer(domain_hdl->j_index);
358     CTimer::get("XIOS").suspend();
359  }
360 
361  void cxios_get_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1, int extent2)
362  {
363    CTimer::get("XIOS").resume();
364    CArray<int,2> tmp(j_index,shape(extent1,extent2),neverDeleteData) ;
365    tmp=domain_hdl->j_index.getInheritedValue() ;
366     CTimer::get("XIOS").suspend();
367  }
368 
369  bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl )
370  {
371     CTimer::get("XIOS").resume();
372    return domain_hdl->j_index.hasInheritedValue();
373     CTimer::get("XIOS").suspend();
374  }
375 
376 
377 
378  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
379  {
380     CTimer::get("XIOS").resume();
381    domain_hdl->jbegin.setValue(jbegin);
382    domain_hdl->sendAttributToServer(domain_hdl->jbegin);
383     CTimer::get("XIOS").suspend();
384  }
385 
386  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin)
387  {
388    *jbegin = domain_hdl->jbegin.getInheritedValue();
389  }
390 
391  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl )
392  {
393     CTimer::get("XIOS").resume();
394    return domain_hdl->jbegin.hasInheritedValue();
395     CTimer::get("XIOS").suspend();
396  }
397 
398 
399 
400  void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend)
401  {
402     CTimer::get("XIOS").resume();
403    domain_hdl->jend.setValue(jend);
404    domain_hdl->sendAttributToServer(domain_hdl->jend);
405     CTimer::get("XIOS").suspend();
406  }
407 
408  void cxios_get_domain_jend(domain_Ptr domain_hdl, int* jend)
409  {
410    *jend = domain_hdl->jend.getInheritedValue();
411  }
412 
413  bool cxios_is_defined_domain_jend(domain_Ptr domain_hdl )
414  {
415     CTimer::get("XIOS").resume();
416    return domain_hdl->jend.hasInheritedValue();
417     CTimer::get("XIOS").suspend();
418  }
419 
420 
421 
422  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
423  {
424    CTimer::get("XIOS").resume();
425    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
426    domain_hdl->latvalue.reference(tmp.copy());
427    domain_hdl->sendAttributToServer(domain_hdl->latvalue);
428     CTimer::get("XIOS").suspend();
429  }
430 
431  void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
432  {
433    CTimer::get("XIOS").resume();
434    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ;
435    tmp=domain_hdl->latvalue.getInheritedValue() ;
436     CTimer::get("XIOS").suspend();
437  }
438 
439  bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl )
440  {
441     CTimer::get("XIOS").resume();
442    return domain_hdl->latvalue.hasInheritedValue();
443     CTimer::get("XIOS").suspend();
444  }
445 
446 
447 
448  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
449  {
450    std::string long_name_str;
451    if(!cstr2string(long_name, long_name_size, long_name_str)) return;
452     CTimer::get("XIOS").resume();
453    domain_hdl->long_name.setValue(long_name_str);
454    domain_hdl->sendAttributToServer(domain_hdl->long_name);
455     CTimer::get("XIOS").suspend();
456  }
457 
458  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
459  {
460     CTimer::get("XIOS").resume();
461    if(!string_copy(domain_hdl->long_name.getInheritedValue(),long_name , long_name_size))
462      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
463     CTimer::get("XIOS").suspend();
464  }
465 
466  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl )
467  {
468     CTimer::get("XIOS").resume();
469    return domain_hdl->long_name.hasInheritedValue();
470     CTimer::get("XIOS").suspend();
471  }
472 
473 
474 
475  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
476  {
477    CTimer::get("XIOS").resume();
478    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
479    domain_hdl->lonvalue.reference(tmp.copy());
480    domain_hdl->sendAttributToServer(domain_hdl->lonvalue);
481     CTimer::get("XIOS").suspend();
482  }
483 
484  void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
485  {
486    CTimer::get("XIOS").resume();
487    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ;
488    tmp=domain_hdl->lonvalue.getInheritedValue() ;
489     CTimer::get("XIOS").suspend();
490  }
491 
492  bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl )
493  {
494     CTimer::get("XIOS").resume();
495    return domain_hdl->lonvalue.hasInheritedValue();
496     CTimer::get("XIOS").suspend();
497  }
498 
499 
500 
501  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
502  {
503    CTimer::get("XIOS").resume();
504    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
505    domain_hdl->mask.reference(tmp.copy());
506    domain_hdl->sendAttributToServer(domain_hdl->mask);
507     CTimer::get("XIOS").suspend();
508  }
509 
510  void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
511  {
512    CTimer::get("XIOS").resume();
513    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ;
514    tmp=domain_hdl->mask.getInheritedValue() ;
515     CTimer::get("XIOS").suspend();
516  }
517 
518  bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl )
519  {
520     CTimer::get("XIOS").resume();
521    return domain_hdl->mask.hasInheritedValue();
522     CTimer::get("XIOS").suspend();
523  }
524 
525 
526 
527  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
528  {
529    std::string name_str;
530    if(!cstr2string(name, name_size, name_str)) return;
531     CTimer::get("XIOS").resume();
532    domain_hdl->name.setValue(name_str);
533    domain_hdl->sendAttributToServer(domain_hdl->name);
534     CTimer::get("XIOS").suspend();
535  }
536 
537  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
538  {
539     CTimer::get("XIOS").resume();
540    if(!string_copy(domain_hdl->name.getInheritedValue(),name , name_size))
541      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short");
542     CTimer::get("XIOS").suspend();
543  }
544 
545  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl )
546  {
547     CTimer::get("XIOS").resume();
548    return domain_hdl->name.hasInheritedValue();
549     CTimer::get("XIOS").suspend();
550  }
551 
552 
553 
554  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
555  {
556     CTimer::get("XIOS").resume();
557    domain_hdl->ni.setValue(ni);
558    domain_hdl->sendAttributToServer(domain_hdl->ni);
559     CTimer::get("XIOS").suspend();
560  }
561 
562  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni)
563  {
564    *ni = domain_hdl->ni.getInheritedValue();
565  }
566 
567  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl )
568  {
569     CTimer::get("XIOS").resume();
570    return domain_hdl->ni.hasInheritedValue();
571     CTimer::get("XIOS").suspend();
572  }
573 
574 
575 
576  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
577  {
578     CTimer::get("XIOS").resume();
579    domain_hdl->ni_glo.setValue(ni_glo);
580    domain_hdl->sendAttributToServer(domain_hdl->ni_glo);
581     CTimer::get("XIOS").suspend();
582  }
583 
584  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo)
585  {
586    *ni_glo = domain_hdl->ni_glo.getInheritedValue();
587  }
588 
589  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl )
590  {
591     CTimer::get("XIOS").resume();
592    return domain_hdl->ni_glo.hasInheritedValue();
593     CTimer::get("XIOS").suspend();
594  }
595 
596 
597 
598  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
599  {
600     CTimer::get("XIOS").resume();
601    domain_hdl->nj.setValue(nj);
602    domain_hdl->sendAttributToServer(domain_hdl->nj);
603     CTimer::get("XIOS").suspend();
604  }
605 
606  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj)
607  {
608    *nj = domain_hdl->nj.getInheritedValue();
609  }
610 
611  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl )
612  {
613     CTimer::get("XIOS").resume();
614    return domain_hdl->nj.hasInheritedValue();
615     CTimer::get("XIOS").suspend();
616  }
617 
618 
619 
620  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
621  {
622     CTimer::get("XIOS").resume();
623    domain_hdl->nj_glo.setValue(nj_glo);
624    domain_hdl->sendAttributToServer(domain_hdl->nj_glo);
625     CTimer::get("XIOS").suspend();
626  }
627 
628  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo)
629  {
630    *nj_glo = domain_hdl->nj_glo.getInheritedValue();
631  }
632 
633  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl )
634  {
635     CTimer::get("XIOS").resume();
636    return domain_hdl->nj_glo.hasInheritedValue();
637     CTimer::get("XIOS").suspend();
638  }
639 
640 
641 
642  void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex)
643  {
644     CTimer::get("XIOS").resume();
645    domain_hdl->nvertex.setValue(nvertex);
646    domain_hdl->sendAttributToServer(domain_hdl->nvertex);
647     CTimer::get("XIOS").suspend();
648  }
649 
650  void cxios_get_domain_nvertex(domain_Ptr domain_hdl, int* nvertex)
651  {
652    *nvertex = domain_hdl->nvertex.getInheritedValue();
653  }
654 
655  bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl )
656  {
657     CTimer::get("XIOS").resume();
658    return domain_hdl->nvertex.hasInheritedValue();
659     CTimer::get("XIOS").suspend();
660  }
661 
662 
663 
664  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
665  {
666    std::string standard_name_str;
667    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
668     CTimer::get("XIOS").resume();
669    domain_hdl->standard_name.setValue(standard_name_str);
670    domain_hdl->sendAttributToServer(domain_hdl->standard_name);
671     CTimer::get("XIOS").suspend();
672  }
673 
674  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
675  {
676     CTimer::get("XIOS").resume();
677    if(!string_copy(domain_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size))
678      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
679     CTimer::get("XIOS").suspend();
680  }
681 
682  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl )
683  {
684     CTimer::get("XIOS").resume();
685    return domain_hdl->standard_name.hasInheritedValue();
686     CTimer::get("XIOS").suspend();
687  }
688 
689 
690 
691  void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size)
692  {
693    std::string type_str;
694    if(!cstr2string(type, type_size, type_str)) return;
695     CTimer::get("XIOS").resume();
696    domain_hdl->type.fromString(type_str);
697    domain_hdl->sendAttributToServer(domain_hdl->type);
698     CTimer::get("XIOS").suspend();
699  }
700 
701  void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)
702  {
703     CTimer::get("XIOS").resume();
704    if(!string_copy(domain_hdl->type.getInheritedStringValue(),type , type_size))
705      ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", <<"Input string is to short");
706     CTimer::get("XIOS").suspend();
707  }
708 
709  bool cxios_is_defined_domain_type(domain_Ptr domain_hdl )
710  {
711     CTimer::get("XIOS").resume();
712    return domain_hdl->type.hasInheritedValue();
713     CTimer::get("XIOS").suspend();
714  }
715 
716 
717 
718  void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin)
719  {
720     CTimer::get("XIOS").resume();
721    domain_hdl->zoom_ibegin.setValue(zoom_ibegin);
722    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin);
723     CTimer::get("XIOS").suspend();
724  }
725 
726  void cxios_get_domain_zoom_ibegin(domain_Ptr domain_hdl, int* zoom_ibegin)
727  {
728    *zoom_ibegin = domain_hdl->zoom_ibegin.getInheritedValue();
729  }
730 
731  bool cxios_is_defined_domain_zoom_ibegin(domain_Ptr domain_hdl )
732  {
733     CTimer::get("XIOS").resume();
734    return domain_hdl->zoom_ibegin.hasInheritedValue();
735     CTimer::get("XIOS").suspend();
736  }
737 
738 
739 
740  void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc)
741  {
742     CTimer::get("XIOS").resume();
743    domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
744    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin_loc);
745     CTimer::get("XIOS").suspend();
746  }
747 
748  void cxios_get_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int* zoom_ibegin_loc)
749  {
750    *zoom_ibegin_loc = domain_hdl->zoom_ibegin_loc.getInheritedValue();
751  }
752 
753  bool cxios_is_defined_domain_zoom_ibegin_loc(domain_Ptr domain_hdl )
754  {
755     CTimer::get("XIOS").resume();
756    return domain_hdl->zoom_ibegin_loc.hasInheritedValue();
757     CTimer::get("XIOS").suspend();
758  }
759 
760 
761 
762  void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin)
763  {
764     CTimer::get("XIOS").resume();
765    domain_hdl->zoom_jbegin.setValue(zoom_jbegin);
766    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin);
767     CTimer::get("XIOS").suspend();
768  }
769 
770  void cxios_get_domain_zoom_jbegin(domain_Ptr domain_hdl, int* zoom_jbegin)
771  {
772    *zoom_jbegin = domain_hdl->zoom_jbegin.getInheritedValue();
773  }
774 
775  bool cxios_is_defined_domain_zoom_jbegin(domain_Ptr domain_hdl )
776  {
777     CTimer::get("XIOS").resume();
778    return domain_hdl->zoom_jbegin.hasInheritedValue();
779     CTimer::get("XIOS").suspend();
780  }
781 
782 
783 
784  void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc)
785  {
786     CTimer::get("XIOS").resume();
787    domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
788    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin_loc);
789     CTimer::get("XIOS").suspend();
790  }
791 
792  void cxios_get_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int* zoom_jbegin_loc)
793  {
794    *zoom_jbegin_loc = domain_hdl->zoom_jbegin_loc.getInheritedValue();
795  }
796 
797  bool cxios_is_defined_domain_zoom_jbegin_loc(domain_Ptr domain_hdl )
798  {
799     CTimer::get("XIOS").resume();
800    return domain_hdl->zoom_jbegin_loc.hasInheritedValue();
801     CTimer::get("XIOS").suspend();
802  }
803 
804 
805 
806  void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni)
807  {
808     CTimer::get("XIOS").resume();
809    domain_hdl->zoom_ni.setValue(zoom_ni);
810    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni);
811     CTimer::get("XIOS").suspend();
812  }
813 
814  void cxios_get_domain_zoom_ni(domain_Ptr domain_hdl, int* zoom_ni)
815  {
816    *zoom_ni = domain_hdl->zoom_ni.getInheritedValue();
817  }
818 
819  bool cxios_is_defined_domain_zoom_ni(domain_Ptr domain_hdl )
820  {
821     CTimer::get("XIOS").resume();
822    return domain_hdl->zoom_ni.hasInheritedValue();
823     CTimer::get("XIOS").suspend();
824  }
825 
826 
827 
828  void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc)
829  {
830     CTimer::get("XIOS").resume();
831    domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
832    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni_loc);
833     CTimer::get("XIOS").suspend();
834  }
835 
836  void cxios_get_domain_zoom_ni_loc(domain_Ptr domain_hdl, int* zoom_ni_loc)
837  {
838    *zoom_ni_loc = domain_hdl->zoom_ni_loc.getInheritedValue();
839  }
840 
841  bool cxios_is_defined_domain_zoom_ni_loc(domain_Ptr domain_hdl )
842  {
843     CTimer::get("XIOS").resume();
844    return domain_hdl->zoom_ni_loc.hasInheritedValue();
845     CTimer::get("XIOS").suspend();
846  }
847 
848 
849 
850  void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj)
851  {
852     CTimer::get("XIOS").resume();
853    domain_hdl->zoom_nj.setValue(zoom_nj);
854    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj);
855     CTimer::get("XIOS").suspend();
856  }
857 
858  void cxios_get_domain_zoom_nj(domain_Ptr domain_hdl, int* zoom_nj)
859  {
860    *zoom_nj = domain_hdl->zoom_nj.getInheritedValue();
861  }
862 
863  bool cxios_is_defined_domain_zoom_nj(domain_Ptr domain_hdl )
864  {
865     CTimer::get("XIOS").resume();
866    return domain_hdl->zoom_nj.hasInheritedValue();
867     CTimer::get("XIOS").suspend();
868  }
869 
870 
871 
872  void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc)
873  {
874     CTimer::get("XIOS").resume();
875    domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
876    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj_loc);
877     CTimer::get("XIOS").suspend();
878  }
879 
880  void cxios_get_domain_zoom_nj_loc(domain_Ptr domain_hdl, int* zoom_nj_loc)
881  {
882    *zoom_nj_loc = domain_hdl->zoom_nj_loc.getInheritedValue();
883  }
884 
885  bool cxios_is_defined_domain_zoom_nj_loc(domain_Ptr domain_hdl )
886  {
887     CTimer::get("XIOS").resume();
888    return domain_hdl->zoom_nj_loc.hasInheritedValue();
889     CTimer::get("XIOS").suspend();
890  }
891 
892 
893 
894 
895}
Note: See TracBrowser for help on using the repository browser.