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

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

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

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