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

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