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

Last change on this file since 789 was 789, checked in by rlacroix, 8 years ago

Domain: Remove the domain_src attribute.

It was added but was never used.

  • 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.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 "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::CDomain* domain_Ptr;
19
20  void cxios_set_domain_area(domain_Ptr domain_hdl, double* area, int* extent)
21  {
22    CTimer::get("XIOS").resume();
23    CArray<double,2> tmp(area, shape(extent[0], extent[1]), neverDeleteData);
24    domain_hdl->area.reference(tmp.copy());
25     CTimer::get("XIOS").suspend();
26  }
27
28  void cxios_get_domain_area(domain_Ptr domain_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=domain_hdl->area.getInheritedValue();
33     CTimer::get("XIOS").suspend();
34  }
35
36  bool cxios_is_defined_domain_area(domain_Ptr domain_hdl)
37  {
38     CTimer::get("XIOS").resume();
39     bool isDefined = domain_hdl->area.hasInheritedValue();
40     CTimer::get("XIOS").suspend();
41     return isDefined;
42  }
43
44
45  void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_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    domain_hdl->bounds_lat_1d.reference(tmp.copy());
50     CTimer::get("XIOS").suspend();
51  }
52
53  void cxios_get_domain_bounds_lat_1d(domain_Ptr domain_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=domain_hdl->bounds_lat_1d.getInheritedValue();
58     CTimer::get("XIOS").suspend();
59  }
60
61  bool cxios_is_defined_domain_bounds_lat_1d(domain_Ptr domain_hdl)
62  {
63     CTimer::get("XIOS").resume();
64     bool isDefined = domain_hdl->bounds_lat_1d.hasInheritedValue();
65     CTimer::get("XIOS").suspend();
66     return isDefined;
67  }
68
69
70  void cxios_set_domain_bounds_lat_2d(domain_Ptr domain_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    domain_hdl->bounds_lat_2d.reference(tmp.copy());
75     CTimer::get("XIOS").suspend();
76  }
77
78  void cxios_get_domain_bounds_lat_2d(domain_Ptr domain_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=domain_hdl->bounds_lat_2d.getInheritedValue();
83     CTimer::get("XIOS").suspend();
84  }
85
86  bool cxios_is_defined_domain_bounds_lat_2d(domain_Ptr domain_hdl)
87  {
88     CTimer::get("XIOS").resume();
89     bool isDefined = domain_hdl->bounds_lat_2d.hasInheritedValue();
90     CTimer::get("XIOS").suspend();
91     return isDefined;
92  }
93
94
95  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_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    domain_hdl->bounds_lon_1d.reference(tmp.copy());
100     CTimer::get("XIOS").suspend();
101  }
102
103  void cxios_get_domain_bounds_lon_1d(domain_Ptr domain_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=domain_hdl->bounds_lon_1d.getInheritedValue();
108     CTimer::get("XIOS").suspend();
109  }
110
111  bool cxios_is_defined_domain_bounds_lon_1d(domain_Ptr domain_hdl)
112  {
113     CTimer::get("XIOS").resume();
114     bool isDefined = domain_hdl->bounds_lon_1d.hasInheritedValue();
115     CTimer::get("XIOS").suspend();
116     return isDefined;
117  }
118
119
120  void cxios_set_domain_bounds_lon_2d(domain_Ptr domain_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    domain_hdl->bounds_lon_2d.reference(tmp.copy());
125     CTimer::get("XIOS").suspend();
126  }
127
128  void cxios_get_domain_bounds_lon_2d(domain_Ptr domain_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=domain_hdl->bounds_lon_2d.getInheritedValue();
133     CTimer::get("XIOS").suspend();
134  }
135
136  bool cxios_is_defined_domain_bounds_lon_2d(domain_Ptr domain_hdl)
137  {
138     CTimer::get("XIOS").resume();
139     bool isDefined = domain_hdl->bounds_lon_2d.hasInheritedValue();
140     CTimer::get("XIOS").suspend();
141     return isDefined;
142  }
143
144
145  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
146  {
147    CTimer::get("XIOS").resume();
148    domain_hdl->data_dim.setValue(data_dim);
149    CTimer::get("XIOS").suspend();
150  }
151
152  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim)
153  {
154    CTimer::get("XIOS").resume();
155    *data_dim = domain_hdl->data_dim.getInheritedValue();
156    CTimer::get("XIOS").suspend();
157  }
158
159  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl)
160  {
161     CTimer::get("XIOS").resume();
162     bool isDefined = domain_hdl->data_dim.hasInheritedValue();
163     CTimer::get("XIOS").suspend();
164     return isDefined;
165  }
166
167
168  void cxios_set_domain_data_i_index(domain_Ptr domain_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    domain_hdl->data_i_index.reference(tmp.copy());
173     CTimer::get("XIOS").suspend();
174  }
175
176  void cxios_get_domain_data_i_index(domain_Ptr domain_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=domain_hdl->data_i_index.getInheritedValue();
181     CTimer::get("XIOS").suspend();
182  }
183
184  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl)
185  {
186     CTimer::get("XIOS").resume();
187     bool isDefined = domain_hdl->data_i_index.hasInheritedValue();
188     CTimer::get("XIOS").suspend();
189     return isDefined;
190  }
191
192
193  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
194  {
195    CTimer::get("XIOS").resume();
196    domain_hdl->data_ibegin.setValue(data_ibegin);
197    CTimer::get("XIOS").suspend();
198  }
199
200  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin)
201  {
202    CTimer::get("XIOS").resume();
203    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue();
204    CTimer::get("XIOS").suspend();
205  }
206
207  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl)
208  {
209     CTimer::get("XIOS").resume();
210     bool isDefined = domain_hdl->data_ibegin.hasInheritedValue();
211     CTimer::get("XIOS").suspend();
212     return isDefined;
213  }
214
215
216  void cxios_set_domain_data_j_index(domain_Ptr domain_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    domain_hdl->data_j_index.reference(tmp.copy());
221     CTimer::get("XIOS").suspend();
222  }
223
224  void cxios_get_domain_data_j_index(domain_Ptr domain_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=domain_hdl->data_j_index.getInheritedValue();
229     CTimer::get("XIOS").suspend();
230  }
231
232  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl)
233  {
234     CTimer::get("XIOS").resume();
235     bool isDefined = domain_hdl->data_j_index.hasInheritedValue();
236     CTimer::get("XIOS").suspend();
237     return isDefined;
238  }
239
240
241  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
242  {
243    CTimer::get("XIOS").resume();
244    domain_hdl->data_jbegin.setValue(data_jbegin);
245    CTimer::get("XIOS").suspend();
246  }
247
248  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin)
249  {
250    CTimer::get("XIOS").resume();
251    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue();
252    CTimer::get("XIOS").suspend();
253  }
254
255  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl)
256  {
257     CTimer::get("XIOS").resume();
258     bool isDefined = domain_hdl->data_jbegin.hasInheritedValue();
259     CTimer::get("XIOS").suspend();
260     return isDefined;
261  }
262
263
264  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
265  {
266    CTimer::get("XIOS").resume();
267    domain_hdl->data_ni.setValue(data_ni);
268    CTimer::get("XIOS").suspend();
269  }
270
271  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni)
272  {
273    CTimer::get("XIOS").resume();
274    *data_ni = domain_hdl->data_ni.getInheritedValue();
275    CTimer::get("XIOS").suspend();
276  }
277
278  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl)
279  {
280     CTimer::get("XIOS").resume();
281     bool isDefined = domain_hdl->data_ni.hasInheritedValue();
282     CTimer::get("XIOS").suspend();
283     return isDefined;
284  }
285
286
287  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
288  {
289    CTimer::get("XIOS").resume();
290    domain_hdl->data_nj.setValue(data_nj);
291    CTimer::get("XIOS").suspend();
292  }
293
294  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj)
295  {
296    CTimer::get("XIOS").resume();
297    *data_nj = domain_hdl->data_nj.getInheritedValue();
298    CTimer::get("XIOS").suspend();
299  }
300
301  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl)
302  {
303     CTimer::get("XIOS").resume();
304     bool isDefined = domain_hdl->data_nj.hasInheritedValue();
305     CTimer::get("XIOS").suspend();
306     return isDefined;
307  }
308
309
310  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size)
311  {
312    std::string domain_ref_str;
313    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
314    CTimer::get("XIOS").resume();
315    domain_hdl->domain_ref.setValue(domain_ref_str);
316    CTimer::get("XIOS").suspend();
317  }
318
319  void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)
320  {
321    CTimer::get("XIOS").resume();
322    if (!string_copy(domain_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size))
323      ERROR("void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short");
324    CTimer::get("XIOS").suspend();
325  }
326
327  bool cxios_is_defined_domain_domain_ref(domain_Ptr domain_hdl)
328  {
329     CTimer::get("XIOS").resume();
330     bool isDefined = domain_hdl->domain_ref.hasInheritedValue();
331     CTimer::get("XIOS").suspend();
332     return isDefined;
333  }
334
335
336  void cxios_set_domain_i_index(domain_Ptr domain_hdl, int* i_index, int* extent)
337  {
338    CTimer::get("XIOS").resume();
339    CArray<int,1> tmp(i_index, shape(extent[0]), neverDeleteData);
340    domain_hdl->i_index.reference(tmp.copy());
341     CTimer::get("XIOS").suspend();
342  }
343
344  void cxios_get_domain_i_index(domain_Ptr domain_hdl, int* i_index, int* extent)
345  {
346    CTimer::get("XIOS").resume();
347    CArray<int,1> tmp(i_index, shape(extent[0]), neverDeleteData);
348    tmp=domain_hdl->i_index.getInheritedValue();
349     CTimer::get("XIOS").suspend();
350  }
351
352  bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl)
353  {
354     CTimer::get("XIOS").resume();
355     bool isDefined = domain_hdl->i_index.hasInheritedValue();
356     CTimer::get("XIOS").suspend();
357     return isDefined;
358  }
359
360
361  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
362  {
363    CTimer::get("XIOS").resume();
364    domain_hdl->ibegin.setValue(ibegin);
365    CTimer::get("XIOS").suspend();
366  }
367
368  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin)
369  {
370    CTimer::get("XIOS").resume();
371    *ibegin = domain_hdl->ibegin.getInheritedValue();
372    CTimer::get("XIOS").suspend();
373  }
374
375  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl)
376  {
377     CTimer::get("XIOS").resume();
378     bool isDefined = domain_hdl->ibegin.hasInheritedValue();
379     CTimer::get("XIOS").suspend();
380     return isDefined;
381  }
382
383
384  void cxios_set_domain_j_index(domain_Ptr domain_hdl, int* j_index, int* extent)
385  {
386    CTimer::get("XIOS").resume();
387    CArray<int,1> tmp(j_index, shape(extent[0]), neverDeleteData);
388    domain_hdl->j_index.reference(tmp.copy());
389     CTimer::get("XIOS").suspend();
390  }
391
392  void cxios_get_domain_j_index(domain_Ptr domain_hdl, int* j_index, int* extent)
393  {
394    CTimer::get("XIOS").resume();
395    CArray<int,1> tmp(j_index, shape(extent[0]), neverDeleteData);
396    tmp=domain_hdl->j_index.getInheritedValue();
397     CTimer::get("XIOS").suspend();
398  }
399
400  bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl)
401  {
402     CTimer::get("XIOS").resume();
403     bool isDefined = domain_hdl->j_index.hasInheritedValue();
404     CTimer::get("XIOS").suspend();
405     return isDefined;
406  }
407
408
409  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
410  {
411    CTimer::get("XIOS").resume();
412    domain_hdl->jbegin.setValue(jbegin);
413    CTimer::get("XIOS").suspend();
414  }
415
416  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin)
417  {
418    CTimer::get("XIOS").resume();
419    *jbegin = domain_hdl->jbegin.getInheritedValue();
420    CTimer::get("XIOS").suspend();
421  }
422
423  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl)
424  {
425     CTimer::get("XIOS").resume();
426     bool isDefined = domain_hdl->jbegin.hasInheritedValue();
427     CTimer::get("XIOS").suspend();
428     return isDefined;
429  }
430
431
432  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent)
433  {
434    CTimer::get("XIOS").resume();
435    CArray<double,1> tmp(latvalue_1d, shape(extent[0]), neverDeleteData);
436    domain_hdl->latvalue_1d.reference(tmp.copy());
437     CTimer::get("XIOS").suspend();
438  }
439
440  void cxios_get_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent)
441  {
442    CTimer::get("XIOS").resume();
443    CArray<double,1> tmp(latvalue_1d, shape(extent[0]), neverDeleteData);
444    tmp=domain_hdl->latvalue_1d.getInheritedValue();
445     CTimer::get("XIOS").suspend();
446  }
447
448  bool cxios_is_defined_domain_latvalue_1d(domain_Ptr domain_hdl)
449  {
450     CTimer::get("XIOS").resume();
451     bool isDefined = domain_hdl->latvalue_1d.hasInheritedValue();
452     CTimer::get("XIOS").suspend();
453     return isDefined;
454  }
455
456
457  void cxios_set_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int* extent)
458  {
459    CTimer::get("XIOS").resume();
460    CArray<double,2> tmp(latvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
461    domain_hdl->latvalue_2d.reference(tmp.copy());
462     CTimer::get("XIOS").suspend();
463  }
464
465  void cxios_get_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int* extent)
466  {
467    CTimer::get("XIOS").resume();
468    CArray<double,2> tmp(latvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
469    tmp=domain_hdl->latvalue_2d.getInheritedValue();
470     CTimer::get("XIOS").suspend();
471  }
472
473  bool cxios_is_defined_domain_latvalue_2d(domain_Ptr domain_hdl)
474  {
475     CTimer::get("XIOS").resume();
476     bool isDefined = domain_hdl->latvalue_2d.hasInheritedValue();
477     CTimer::get("XIOS").suspend();
478     return isDefined;
479  }
480
481
482  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
483  {
484    std::string long_name_str;
485    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
486    CTimer::get("XIOS").resume();
487    domain_hdl->long_name.setValue(long_name_str);
488    CTimer::get("XIOS").suspend();
489  }
490
491  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
492  {
493    CTimer::get("XIOS").resume();
494    if (!string_copy(domain_hdl->long_name.getInheritedValue(), long_name, long_name_size))
495      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", << "Input string is too short");
496    CTimer::get("XIOS").suspend();
497  }
498
499  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl)
500  {
501     CTimer::get("XIOS").resume();
502     bool isDefined = domain_hdl->long_name.hasInheritedValue();
503     CTimer::get("XIOS").suspend();
504     return isDefined;
505  }
506
507
508  void cxios_set_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int* extent)
509  {
510    CTimer::get("XIOS").resume();
511    CArray<double,1> tmp(lonvalue_1d, shape(extent[0]), neverDeleteData);
512    domain_hdl->lonvalue_1d.reference(tmp.copy());
513     CTimer::get("XIOS").suspend();
514  }
515
516  void cxios_get_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int* extent)
517  {
518    CTimer::get("XIOS").resume();
519    CArray<double,1> tmp(lonvalue_1d, shape(extent[0]), neverDeleteData);
520    tmp=domain_hdl->lonvalue_1d.getInheritedValue();
521     CTimer::get("XIOS").suspend();
522  }
523
524  bool cxios_is_defined_domain_lonvalue_1d(domain_Ptr domain_hdl)
525  {
526     CTimer::get("XIOS").resume();
527     bool isDefined = domain_hdl->lonvalue_1d.hasInheritedValue();
528     CTimer::get("XIOS").suspend();
529     return isDefined;
530  }
531
532
533  void cxios_set_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int* extent)
534  {
535    CTimer::get("XIOS").resume();
536    CArray<double,2> tmp(lonvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
537    domain_hdl->lonvalue_2d.reference(tmp.copy());
538     CTimer::get("XIOS").suspend();
539  }
540
541  void cxios_get_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int* extent)
542  {
543    CTimer::get("XIOS").resume();
544    CArray<double,2> tmp(lonvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
545    tmp=domain_hdl->lonvalue_2d.getInheritedValue();
546     CTimer::get("XIOS").suspend();
547  }
548
549  bool cxios_is_defined_domain_lonvalue_2d(domain_Ptr domain_hdl)
550  {
551     CTimer::get("XIOS").resume();
552     bool isDefined = domain_hdl->lonvalue_2d.hasInheritedValue();
553     CTimer::get("XIOS").suspend();
554     return isDefined;
555  }
556
557
558  void cxios_set_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int* extent)
559  {
560    CTimer::get("XIOS").resume();
561    CArray<bool,1> tmp(mask_1d, shape(extent[0]), neverDeleteData);
562    domain_hdl->mask_1d.reference(tmp.copy());
563     CTimer::get("XIOS").suspend();
564  }
565
566  void cxios_get_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int* extent)
567  {
568    CTimer::get("XIOS").resume();
569    CArray<bool,1> tmp(mask_1d, shape(extent[0]), neverDeleteData);
570    tmp=domain_hdl->mask_1d.getInheritedValue();
571     CTimer::get("XIOS").suspend();
572  }
573
574  bool cxios_is_defined_domain_mask_1d(domain_Ptr domain_hdl)
575  {
576     CTimer::get("XIOS").resume();
577     bool isDefined = domain_hdl->mask_1d.hasInheritedValue();
578     CTimer::get("XIOS").suspend();
579     return isDefined;
580  }
581
582
583  void cxios_set_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int* extent)
584  {
585    CTimer::get("XIOS").resume();
586    CArray<bool,2> tmp(mask_2d, shape(extent[0], extent[1]), neverDeleteData);
587    domain_hdl->mask_2d.reference(tmp.copy());
588     CTimer::get("XIOS").suspend();
589  }
590
591  void cxios_get_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int* extent)
592  {
593    CTimer::get("XIOS").resume();
594    CArray<bool,2> tmp(mask_2d, shape(extent[0], extent[1]), neverDeleteData);
595    tmp=domain_hdl->mask_2d.getInheritedValue();
596     CTimer::get("XIOS").suspend();
597  }
598
599  bool cxios_is_defined_domain_mask_2d(domain_Ptr domain_hdl)
600  {
601     CTimer::get("XIOS").resume();
602     bool isDefined = domain_hdl->mask_2d.hasInheritedValue();
603     CTimer::get("XIOS").suspend();
604     return isDefined;
605  }
606
607
608  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
609  {
610    std::string name_str;
611    if (!cstr2string(name, name_size, name_str)) return;
612    CTimer::get("XIOS").resume();
613    domain_hdl->name.setValue(name_str);
614    CTimer::get("XIOS").suspend();
615  }
616
617  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
618  {
619    CTimer::get("XIOS").resume();
620    if (!string_copy(domain_hdl->name.getInheritedValue(), name, name_size))
621      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", << "Input string is too short");
622    CTimer::get("XIOS").suspend();
623  }
624
625  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl)
626  {
627     CTimer::get("XIOS").resume();
628     bool isDefined = domain_hdl->name.hasInheritedValue();
629     CTimer::get("XIOS").suspend();
630     return isDefined;
631  }
632
633
634  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
635  {
636    CTimer::get("XIOS").resume();
637    domain_hdl->ni.setValue(ni);
638    CTimer::get("XIOS").suspend();
639  }
640
641  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni)
642  {
643    CTimer::get("XIOS").resume();
644    *ni = domain_hdl->ni.getInheritedValue();
645    CTimer::get("XIOS").suspend();
646  }
647
648  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl)
649  {
650     CTimer::get("XIOS").resume();
651     bool isDefined = domain_hdl->ni.hasInheritedValue();
652     CTimer::get("XIOS").suspend();
653     return isDefined;
654  }
655
656
657  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
658  {
659    CTimer::get("XIOS").resume();
660    domain_hdl->ni_glo.setValue(ni_glo);
661    CTimer::get("XIOS").suspend();
662  }
663
664  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo)
665  {
666    CTimer::get("XIOS").resume();
667    *ni_glo = domain_hdl->ni_glo.getInheritedValue();
668    CTimer::get("XIOS").suspend();
669  }
670
671  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl)
672  {
673     CTimer::get("XIOS").resume();
674     bool isDefined = domain_hdl->ni_glo.hasInheritedValue();
675     CTimer::get("XIOS").suspend();
676     return isDefined;
677  }
678
679
680  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
681  {
682    CTimer::get("XIOS").resume();
683    domain_hdl->nj.setValue(nj);
684    CTimer::get("XIOS").suspend();
685  }
686
687  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj)
688  {
689    CTimer::get("XIOS").resume();
690    *nj = domain_hdl->nj.getInheritedValue();
691    CTimer::get("XIOS").suspend();
692  }
693
694  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl)
695  {
696     CTimer::get("XIOS").resume();
697     bool isDefined = domain_hdl->nj.hasInheritedValue();
698     CTimer::get("XIOS").suspend();
699     return isDefined;
700  }
701
702
703  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
704  {
705    CTimer::get("XIOS").resume();
706    domain_hdl->nj_glo.setValue(nj_glo);
707    CTimer::get("XIOS").suspend();
708  }
709
710  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo)
711  {
712    CTimer::get("XIOS").resume();
713    *nj_glo = domain_hdl->nj_glo.getInheritedValue();
714    CTimer::get("XIOS").suspend();
715  }
716
717  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl)
718  {
719     CTimer::get("XIOS").resume();
720     bool isDefined = domain_hdl->nj_glo.hasInheritedValue();
721     CTimer::get("XIOS").suspend();
722     return isDefined;
723  }
724
725
726  void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex)
727  {
728    CTimer::get("XIOS").resume();
729    domain_hdl->nvertex.setValue(nvertex);
730    CTimer::get("XIOS").suspend();
731  }
732
733  void cxios_get_domain_nvertex(domain_Ptr domain_hdl, int* nvertex)
734  {
735    CTimer::get("XIOS").resume();
736    *nvertex = domain_hdl->nvertex.getInheritedValue();
737    CTimer::get("XIOS").suspend();
738  }
739
740  bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl)
741  {
742     CTimer::get("XIOS").resume();
743     bool isDefined = domain_hdl->nvertex.hasInheritedValue();
744     CTimer::get("XIOS").suspend();
745     return isDefined;
746  }
747
748
749  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
750  {
751    std::string standard_name_str;
752    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
753    CTimer::get("XIOS").resume();
754    domain_hdl->standard_name.setValue(standard_name_str);
755    CTimer::get("XIOS").suspend();
756  }
757
758  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
759  {
760    CTimer::get("XIOS").resume();
761    if (!string_copy(domain_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
762      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
763    CTimer::get("XIOS").suspend();
764  }
765
766  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl)
767  {
768     CTimer::get("XIOS").resume();
769     bool isDefined = domain_hdl->standard_name.hasInheritedValue();
770     CTimer::get("XIOS").suspend();
771     return isDefined;
772  }
773
774
775  void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size)
776  {
777    std::string type_str;
778    if (!cstr2string(type, type_size, type_str)) return;
779    CTimer::get("XIOS").resume();
780    domain_hdl->type.fromString(type_str);
781    CTimer::get("XIOS").suspend();
782  }
783
784  void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)
785  {
786    CTimer::get("XIOS").resume();
787    if (!string_copy(domain_hdl->type.getInheritedStringValue(), type, type_size))
788      ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", << "Input string is too short");
789    CTimer::get("XIOS").suspend();
790  }
791
792  bool cxios_is_defined_domain_type(domain_Ptr domain_hdl)
793  {
794     CTimer::get("XIOS").resume();
795     bool isDefined = domain_hdl->type.hasInheritedValue();
796     CTimer::get("XIOS").suspend();
797     return isDefined;
798  }
799}
Note: See TracBrowser for help on using the repository browser.