source: XIOS/dev/dev_olga/src/interface/c_attr/icaxisgroup_attr.cpp @ 1158

Last change on this file since 1158 was 1158, checked in by oabramkina, 7 years ago

Two server levels: merging with trunk r1137.
There are bugs.

  • 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: 17.0 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::CAxisGroup* axisgroup_Ptr;
19
20  void cxios_set_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, const char * axis_ref, int axis_ref_size)
21  {
22    std::string axis_ref_str;
23    if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
24    CTimer::get("XIOS").resume();
25    axisgroup_hdl->axis_ref.setValue(axis_ref_str);
26    CTimer::get("XIOS").suspend();
27  }
28
29  void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)
30  {
31    CTimer::get("XIOS").resume();
32    if (!string_copy(axisgroup_hdl->axis_ref.getInheritedValue(), axis_ref, axis_ref_size))
33      ERROR("void cxios_get_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl, char * axis_ref, int axis_ref_size)", << "Input string is too short");
34    CTimer::get("XIOS").suspend();
35  }
36
37  bool cxios_is_defined_axisgroup_axis_ref(axisgroup_Ptr axisgroup_hdl)
38  {
39     CTimer::get("XIOS").resume();
40     bool isDefined = axisgroup_hdl->axis_ref.hasInheritedValue();
41     CTimer::get("XIOS").suspend();
42     return isDefined;
43  }
44
45
46  void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin)
47  {
48    CTimer::get("XIOS").resume();
49    axisgroup_hdl->begin.setValue(begin);
50    CTimer::get("XIOS").suspend();
51  }
52
53  void cxios_get_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int* begin)
54  {
55    CTimer::get("XIOS").resume();
56    *begin = axisgroup_hdl->begin.getInheritedValue();
57    CTimer::get("XIOS").suspend();
58  }
59
60  bool cxios_is_defined_axisgroup_begin(axisgroup_Ptr axisgroup_hdl)
61  {
62     CTimer::get("XIOS").resume();
63     bool isDefined = axisgroup_hdl->begin.hasInheritedValue();
64     CTimer::get("XIOS").suspend();
65     return isDefined;
66  }
67
68
69  void cxios_set_axisgroup_bounds(axisgroup_Ptr axisgroup_hdl, double* bounds, int* extent)
70  {
71    CTimer::get("XIOS").resume();
72    CArray<double,2> tmp(bounds, shape(extent[0], extent[1]), neverDeleteData);
73    axisgroup_hdl->bounds.reference(tmp.copy());
74     CTimer::get("XIOS").suspend();
75  }
76
77  void cxios_get_axisgroup_bounds(axisgroup_Ptr axisgroup_hdl, double* bounds, int* extent)
78  {
79    CTimer::get("XIOS").resume();
80    CArray<double,2> tmp(bounds, shape(extent[0], extent[1]), neverDeleteData);
81    tmp=axisgroup_hdl->bounds.getInheritedValue();
82     CTimer::get("XIOS").suspend();
83  }
84
85  bool cxios_is_defined_axisgroup_bounds(axisgroup_Ptr axisgroup_hdl)
86  {
87     CTimer::get("XIOS").resume();
88     bool isDefined = axisgroup_hdl->bounds.hasInheritedValue();
89     CTimer::get("XIOS").suspend();
90     return isDefined;
91  }
92
93
94  void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin)
95  {
96    CTimer::get("XIOS").resume();
97    axisgroup_hdl->data_begin.setValue(data_begin);
98    CTimer::get("XIOS").suspend();
99  }
100
101  void cxios_get_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int* data_begin)
102  {
103    CTimer::get("XIOS").resume();
104    *data_begin = axisgroup_hdl->data_begin.getInheritedValue();
105    CTimer::get("XIOS").suspend();
106  }
107
108  bool cxios_is_defined_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl)
109  {
110     CTimer::get("XIOS").resume();
111     bool isDefined = axisgroup_hdl->data_begin.hasInheritedValue();
112     CTimer::get("XIOS").suspend();
113     return isDefined;
114  }
115
116
117  void cxios_set_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int* extent)
118  {
119    CTimer::get("XIOS").resume();
120    CArray<int,1> tmp(data_index, shape(extent[0]), neverDeleteData);
121    axisgroup_hdl->data_index.reference(tmp.copy());
122     CTimer::get("XIOS").suspend();
123  }
124
125  void cxios_get_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int* extent)
126  {
127    CTimer::get("XIOS").resume();
128    CArray<int,1> tmp(data_index, shape(extent[0]), neverDeleteData);
129    tmp=axisgroup_hdl->data_index.getInheritedValue();
130     CTimer::get("XIOS").suspend();
131  }
132
133  bool cxios_is_defined_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl)
134  {
135     CTimer::get("XIOS").resume();
136     bool isDefined = axisgroup_hdl->data_index.hasInheritedValue();
137     CTimer::get("XIOS").suspend();
138     return isDefined;
139  }
140
141
142  void cxios_set_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int data_n)
143  {
144    CTimer::get("XIOS").resume();
145    axisgroup_hdl->data_n.setValue(data_n);
146    CTimer::get("XIOS").suspend();
147  }
148
149  void cxios_get_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int* data_n)
150  {
151    CTimer::get("XIOS").resume();
152    *data_n = axisgroup_hdl->data_n.getInheritedValue();
153    CTimer::get("XIOS").suspend();
154  }
155
156  bool cxios_is_defined_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl)
157  {
158     CTimer::get("XIOS").resume();
159     bool isDefined = axisgroup_hdl->data_n.hasInheritedValue();
160     CTimer::get("XIOS").suspend();
161     return isDefined;
162  }
163
164
165  void cxios_set_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, const char * group_ref, int group_ref_size)
166  {
167    std::string group_ref_str;
168    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
169    CTimer::get("XIOS").resume();
170    axisgroup_hdl->group_ref.setValue(group_ref_str);
171    CTimer::get("XIOS").suspend();
172  }
173
174  void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)
175  {
176    CTimer::get("XIOS").resume();
177    if (!string_copy(axisgroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size))
178      ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short");
179    CTimer::get("XIOS").suspend();
180  }
181
182  bool cxios_is_defined_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl)
183  {
184     CTimer::get("XIOS").resume();
185     bool isDefined = axisgroup_hdl->group_ref.hasInheritedValue();
186     CTimer::get("XIOS").suspend();
187     return isDefined;
188  }
189
190
191  void cxios_set_axisgroup_index(axisgroup_Ptr axisgroup_hdl, int* index, int* extent)
192  {
193    CTimer::get("XIOS").resume();
194    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
195    axisgroup_hdl->index.reference(tmp.copy());
196     CTimer::get("XIOS").suspend();
197  }
198
199  void cxios_get_axisgroup_index(axisgroup_Ptr axisgroup_hdl, int* index, int* extent)
200  {
201    CTimer::get("XIOS").resume();
202    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
203    tmp=axisgroup_hdl->index.getInheritedValue();
204     CTimer::get("XIOS").suspend();
205  }
206
207  bool cxios_is_defined_axisgroup_index(axisgroup_Ptr axisgroup_hdl)
208  {
209     CTimer::get("XIOS").resume();
210     bool isDefined = axisgroup_hdl->index.hasInheritedValue();
211     CTimer::get("XIOS").suspend();
212     return isDefined;
213  }
214
215
216  void cxios_set_axisgroup_label(axisgroup_Ptr axisgroup_hdl, char* label, int str_len, int* str_size, int* extent)
217  {
218    CTimer::get("XIOS").resume();
219    axisgroup_hdl->label.resize(shape(extent[0]));
220    Array<StdString,1>::iterator it, itb=axisgroup_hdl->label.begin(), ite=axisgroup_hdl->label.end() ;
221    int i, n ;
222    for(it=itb, i=0, n=0 ; it!=ite ; ++it,n+=str_len,++i) *it=StdString(&label[n],str_size[i]) ;
223    CTimer::get("XIOS").suspend();
224  }
225
226  void cxios_get_axisgroup_label(axisgroup_Ptr axisgroup_hdl, char* label, int str_size, int* extent)
227  {
228    CTimer::get("XIOS").resume();
229    Array<StdString,1>::const_iterator it, itb=axisgroup_hdl->label.getInheritedValue().begin(), ite=axisgroup_hdl->label.getInheritedValue().end() ;
230    int n ;
231    for(it=itb, n=0 ; it!=ite ; ++it, n+=str_size) it->copy(&label[n],it->size()) ; 
232    CTimer::get("XIOS").suspend();
233  }
234
235  bool cxios_is_defined_axisgroup_label(axisgroup_Ptr axisgroup_hdl)
236  {
237     CTimer::get("XIOS").resume();
238     bool isDefined = axisgroup_hdl->label.hasInheritedValue();
239     CTimer::get("XIOS").suspend();
240     return isDefined;
241  }
242
243
244  void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size)
245  {
246    std::string long_name_str;
247    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
248    CTimer::get("XIOS").resume();
249    axisgroup_hdl->long_name.setValue(long_name_str);
250    CTimer::get("XIOS").suspend();
251  }
252
253  void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)
254  {
255    CTimer::get("XIOS").resume();
256    if (!string_copy(axisgroup_hdl->long_name.getInheritedValue(), long_name, long_name_size))
257      ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", << "Input string is too short");
258    CTimer::get("XIOS").suspend();
259  }
260
261  bool cxios_is_defined_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl)
262  {
263     CTimer::get("XIOS").resume();
264     bool isDefined = axisgroup_hdl->long_name.hasInheritedValue();
265     CTimer::get("XIOS").suspend();
266     return isDefined;
267  }
268
269
270  void cxios_set_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int* extent)
271  {
272    CTimer::get("XIOS").resume();
273    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
274    axisgroup_hdl->mask.reference(tmp.copy());
275     CTimer::get("XIOS").suspend();
276  }
277
278  void cxios_get_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int* extent)
279  {
280    CTimer::get("XIOS").resume();
281    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
282    tmp=axisgroup_hdl->mask.getInheritedValue();
283     CTimer::get("XIOS").suspend();
284  }
285
286  bool cxios_is_defined_axisgroup_mask(axisgroup_Ptr axisgroup_hdl)
287  {
288     CTimer::get("XIOS").resume();
289     bool isDefined = axisgroup_hdl->mask.hasInheritedValue();
290     CTimer::get("XIOS").suspend();
291     return isDefined;
292  }
293
294
295  void cxios_set_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int n)
296  {
297    CTimer::get("XIOS").resume();
298    axisgroup_hdl->n.setValue(n);
299    CTimer::get("XIOS").suspend();
300  }
301
302  void cxios_get_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int* n)
303  {
304    CTimer::get("XIOS").resume();
305    *n = axisgroup_hdl->n.getInheritedValue();
306    CTimer::get("XIOS").suspend();
307  }
308
309  bool cxios_is_defined_axisgroup_n(axisgroup_Ptr axisgroup_hdl)
310  {
311     CTimer::get("XIOS").resume();
312     bool isDefined = axisgroup_hdl->n.hasInheritedValue();
313     CTimer::get("XIOS").suspend();
314     return isDefined;
315  }
316
317
318  void cxios_set_axisgroup_n_distributed_partition(axisgroup_Ptr axisgroup_hdl, int n_distributed_partition)
319  {
320    CTimer::get("XIOS").resume();
321    axisgroup_hdl->n_distributed_partition.setValue(n_distributed_partition);
322    CTimer::get("XIOS").suspend();
323  }
324
325  void cxios_get_axisgroup_n_distributed_partition(axisgroup_Ptr axisgroup_hdl, int* n_distributed_partition)
326  {
327    CTimer::get("XIOS").resume();
328    *n_distributed_partition = axisgroup_hdl->n_distributed_partition.getInheritedValue();
329    CTimer::get("XIOS").suspend();
330  }
331
332  bool cxios_is_defined_axisgroup_n_distributed_partition(axisgroup_Ptr axisgroup_hdl)
333  {
334     CTimer::get("XIOS").resume();
335     bool isDefined = axisgroup_hdl->n_distributed_partition.hasInheritedValue();
336     CTimer::get("XIOS").suspend();
337     return isDefined;
338  }
339
340
341  void cxios_set_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int n_glo)
342  {
343    CTimer::get("XIOS").resume();
344    axisgroup_hdl->n_glo.setValue(n_glo);
345    CTimer::get("XIOS").suspend();
346  }
347
348  void cxios_get_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int* n_glo)
349  {
350    CTimer::get("XIOS").resume();
351    *n_glo = axisgroup_hdl->n_glo.getInheritedValue();
352    CTimer::get("XIOS").suspend();
353  }
354
355  bool cxios_is_defined_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl)
356  {
357     CTimer::get("XIOS").resume();
358     bool isDefined = axisgroup_hdl->n_glo.hasInheritedValue();
359     CTimer::get("XIOS").suspend();
360     return isDefined;
361  }
362
363
364  void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size)
365  {
366    std::string name_str;
367    if (!cstr2string(name, name_size, name_str)) return;
368    CTimer::get("XIOS").resume();
369    axisgroup_hdl->name.setValue(name_str);
370    CTimer::get("XIOS").suspend();
371  }
372
373  void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)
374  {
375    CTimer::get("XIOS").resume();
376    if (!string_copy(axisgroup_hdl->name.getInheritedValue(), name, name_size))
377      ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", << "Input string is too short");
378    CTimer::get("XIOS").suspend();
379  }
380
381  bool cxios_is_defined_axisgroup_name(axisgroup_Ptr axisgroup_hdl)
382  {
383     CTimer::get("XIOS").resume();
384     bool isDefined = axisgroup_hdl->name.hasInheritedValue();
385     CTimer::get("XIOS").suspend();
386     return isDefined;
387  }
388
389
390  void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size)
391  {
392    std::string positive_str;
393    if (!cstr2string(positive, positive_size, positive_str)) return;
394    CTimer::get("XIOS").resume();
395    axisgroup_hdl->positive.fromString(positive_str);
396    CTimer::get("XIOS").suspend();
397  }
398
399  void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)
400  {
401    CTimer::get("XIOS").resume();
402    if (!string_copy(axisgroup_hdl->positive.getInheritedStringValue(), positive, positive_size))
403      ERROR("void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)", << "Input string is too short");
404    CTimer::get("XIOS").suspend();
405  }
406
407  bool cxios_is_defined_axisgroup_positive(axisgroup_Ptr axisgroup_hdl)
408  {
409     CTimer::get("XIOS").resume();
410     bool isDefined = axisgroup_hdl->positive.hasInheritedValue();
411     CTimer::get("XIOS").suspend();
412     return isDefined;
413  }
414
415
416  void cxios_set_axisgroup_prec(axisgroup_Ptr axisgroup_hdl, int prec)
417  {
418    CTimer::get("XIOS").resume();
419    axisgroup_hdl->prec.setValue(prec);
420    CTimer::get("XIOS").suspend();
421  }
422
423  void cxios_get_axisgroup_prec(axisgroup_Ptr axisgroup_hdl, int* prec)
424  {
425    CTimer::get("XIOS").resume();
426    *prec = axisgroup_hdl->prec.getInheritedValue();
427    CTimer::get("XIOS").suspend();
428  }
429
430  bool cxios_is_defined_axisgroup_prec(axisgroup_Ptr axisgroup_hdl)
431  {
432     CTimer::get("XIOS").resume();
433     bool isDefined = axisgroup_hdl->prec.hasInheritedValue();
434     CTimer::get("XIOS").suspend();
435     return isDefined;
436  }
437
438
439  void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size)
440  {
441    std::string standard_name_str;
442    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
443    CTimer::get("XIOS").resume();
444    axisgroup_hdl->standard_name.setValue(standard_name_str);
445    CTimer::get("XIOS").suspend();
446  }
447
448  void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)
449  {
450    CTimer::get("XIOS").resume();
451    if (!string_copy(axisgroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
452      ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
453    CTimer::get("XIOS").suspend();
454  }
455
456  bool cxios_is_defined_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl)
457  {
458     CTimer::get("XIOS").resume();
459     bool isDefined = axisgroup_hdl->standard_name.hasInheritedValue();
460     CTimer::get("XIOS").suspend();
461     return isDefined;
462  }
463
464
465  void cxios_set_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, const char * unit, int unit_size)
466  {
467    std::string unit_str;
468    if (!cstr2string(unit, unit_size, unit_str)) return;
469    CTimer::get("XIOS").resume();
470    axisgroup_hdl->unit.setValue(unit_str);
471    CTimer::get("XIOS").suspend();
472  }
473
474  void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)
475  {
476    CTimer::get("XIOS").resume();
477    if (!string_copy(axisgroup_hdl->unit.getInheritedValue(), unit, unit_size))
478      ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", << "Input string is too short");
479    CTimer::get("XIOS").suspend();
480  }
481
482  bool cxios_is_defined_axisgroup_unit(axisgroup_Ptr axisgroup_hdl)
483  {
484     CTimer::get("XIOS").resume();
485     bool isDefined = axisgroup_hdl->unit.hasInheritedValue();
486     CTimer::get("XIOS").suspend();
487     return isDefined;
488  }
489
490
491  void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int* extent)
492  {
493    CTimer::get("XIOS").resume();
494    CArray<double,1> tmp(value, shape(extent[0]), neverDeleteData);
495    axisgroup_hdl->value.reference(tmp.copy());
496     CTimer::get("XIOS").suspend();
497  }
498
499  void cxios_get_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int* extent)
500  {
501    CTimer::get("XIOS").resume();
502    CArray<double,1> tmp(value, shape(extent[0]), neverDeleteData);
503    tmp=axisgroup_hdl->value.getInheritedValue();
504     CTimer::get("XIOS").suspend();
505  }
506
507  bool cxios_is_defined_axisgroup_value(axisgroup_Ptr axisgroup_hdl)
508  {
509     CTimer::get("XIOS").resume();
510     bool isDefined = axisgroup_hdl->value.hasInheritedValue();
511     CTimer::get("XIOS").suspend();
512     return isDefined;
513  }
514}
Note: See TracBrowser for help on using the repository browser.