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

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

Fix Fortran interface generation to avoid generating long lines.

Long lines can cause compilation issues with some compilers.

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