source: XMLIO_V2/dev/dev_rv/src/xmlio/iface/interface.cpp @ 152

Last change on this file since 152 was 152, checked in by hozdoba, 11 years ago
File size: 43.8 KB
Line 
1
2
3#include "../xmlioserver.hpp"
4
5#include "attribute_template_impl.hpp"
6#include "object_template_impl.hpp"
7#include "group_template_impl.hpp"
8
9
10extern "C"
11{
12
13
14typedef xmlioserver::tree::CAxis caxis;
15typedef xmlioserver::tree::CField cfield;
16typedef xmlioserver::tree::CDomain cdomain;
17typedef xmlioserver::tree::CGrid cgrid;
18typedef xmlioserver::tree::CFile cfile;
19typedef xmlioserver::tree::CContext ccontext;
20
21typedef xmlioserver::tree::CAxisGroup caxisgroup;
22typedef xmlioserver::tree::CFieldGroup cfieldgroup;
23typedef xmlioserver::tree::CDomainGroup cdomaingroup;
24typedef xmlioserver::tree::CGridGroup cgridgroup;
25typedef xmlioserver::tree::CFileGroup cfilegroup;
26typedef xmlioserver::tree::CContextGroup ccontextgroup;
27
28
29typedef long int XInt, XSize;
30typedef bool XBool;
31typedef void * XPtr;
32typedef char * XString;
33
34typedef enum
35{
36   NOTYPE = 0,
37   DTREATMENT , DATE, CALENDAR, ECONTEXT,
38   EAXIS, EDOMAIN, EFIELD, EFILE, EGRID,
39   GAXIS, GDOMAIN, GFIELD, GFILE, GGRID
40} XDType;
41
42typedef enum
43{
44   NETCDF4 = 0
45} XFileType;
46
47typedef enum
48{ D360 = 0 , ALLLEAP, NOLEAP, JULIAN, GREGORIAN } XCalendarType ;
49
50 void xios_set_axis_name (void * axis_hdl, int ftype , const char * name , const int * name_size)
51 {
52 
53 StdString name_valtemp; 
54 StdSize d, f = 0; 
55 if (*name_size != -1) 
56 { 
57 name_valtemp.append (name, *name_size); 
58 d = name_valtemp.find_first_not_of(' '); 
59 f = name_valtemp.find_last_not_of (' '); 
60 } 
61 StdString name_val = (*name_size != -1) ? name_valtemp.substr(d, f-d+1) : "" ; 
62 
63 if (axis_hdl != NULL) 
64 {
65 if (ftype < GAXIS)
66 {
67 caxis * axis_hdl_ = (caxis *) axis_hdl; 
68 axis_hdl_->name.setValue(name_val); 
69 }
70 else
71 {
72 caxisgroup * axis_hdl_
73 = (caxisgroup *) axis_hdl; 
74 axis_hdl_->name.setValue(name_val); 
75 }
76 }
77 }
78 
79
80
81 void xios_set_axis_standard_name (void * axis_hdl, int ftype , const char * standard_name , const int * standard_name_size)
82 {
83 
84 StdString standard_name_valtemp; 
85 StdSize d, f = 0; 
86 if (*standard_name_size != -1) 
87 { 
88 standard_name_valtemp.append (standard_name, *standard_name_size); 
89 d = standard_name_valtemp.find_first_not_of(' '); 
90 f = standard_name_valtemp.find_last_not_of (' '); 
91 } 
92 StdString standard_name_val = (*standard_name_size != -1) ? standard_name_valtemp.substr(d, f-d+1) : "" ; 
93 
94 if (axis_hdl != NULL) 
95 {
96 if (ftype < GAXIS)
97 {
98 caxis * axis_hdl_ = (caxis *) axis_hdl; 
99 axis_hdl_->standard_name.setValue(standard_name_val); 
100 }
101 else
102 {
103 caxisgroup * axis_hdl_
104 = (caxisgroup *) axis_hdl; 
105 axis_hdl_->standard_name.setValue(standard_name_val); 
106 }
107 }
108 }
109 
110
111
112 void xios_set_axis_long_name (void * axis_hdl, int ftype , const char * long_name , const int * long_name_size)
113 {
114 
115 StdString long_name_valtemp; 
116 StdSize d, f = 0; 
117 if (*long_name_size != -1) 
118 { 
119 long_name_valtemp.append (long_name, *long_name_size); 
120 d = long_name_valtemp.find_first_not_of(' '); 
121 f = long_name_valtemp.find_last_not_of (' '); 
122 } 
123 StdString long_name_val = (*long_name_size != -1) ? long_name_valtemp.substr(d, f-d+1) : "" ; 
124 
125 if (axis_hdl != NULL) 
126 {
127 if (ftype < GAXIS)
128 {
129 caxis * axis_hdl_ = (caxis *) axis_hdl; 
130 axis_hdl_->long_name.setValue(long_name_val); 
131 }
132 else
133 {
134 caxisgroup * axis_hdl_
135 = (caxisgroup *) axis_hdl; 
136 axis_hdl_->long_name.setValue(long_name_val); 
137 }
138 }
139 }
140 
141
142
143 void xios_set_axis_unit (void * axis_hdl, int ftype , const char * unit , const int * unit_size)
144 {
145 
146 StdString unit_valtemp; 
147 StdSize d, f = 0; 
148 if (*unit_size != -1) 
149 { 
150 unit_valtemp.append (unit, *unit_size); 
151 d = unit_valtemp.find_first_not_of(' '); 
152 f = unit_valtemp.find_last_not_of (' '); 
153 } 
154 StdString unit_val = (*unit_size != -1) ? unit_valtemp.substr(d, f-d+1) : "" ; 
155 
156 if (axis_hdl != NULL) 
157 {
158 if (ftype < GAXIS)
159 {
160 caxis * axis_hdl_ = (caxis *) axis_hdl; 
161 axis_hdl_->unit.setValue(unit_val); 
162 }
163 else
164 {
165 caxisgroup * axis_hdl_
166 = (caxisgroup *) axis_hdl; 
167 axis_hdl_->unit.setValue(unit_val); 
168 }
169 }
170 }
171 
172
173
174 void xios_set_axis_size (void * axis_hdl, int ftype , const int * size)
175 {
176 int size_val = *size; 
177 if (axis_hdl != NULL) 
178 {
179 if (ftype < GAXIS)
180 {
181 caxis * axis_hdl_ = (caxis *) axis_hdl; 
182 axis_hdl_->size.setValue(size_val); 
183 }
184 else
185 {
186 caxisgroup * axis_hdl_
187 = (caxisgroup *) axis_hdl; 
188 axis_hdl_->size.setValue(size_val); 
189 }
190 }
191 }
192 
193
194
195 void xios_set_axis_zvalue (void * axis_hdl, int ftype , const double * zvalue , const int * zvalue_extent1)
196 {
197 int zvalue_extent1_val = *zvalue_extent1; 
198 boost::shared_ptr<CArray<double, 1> > zvalue_val
199 (new CArray<double, 1>(boost::extents [zvalue_extent1_val])); 
200 std::copy(zvalue, &(zvalue[zvalue_val->num_elements()]), zvalue_val->data()); 
201 
202 if (axis_hdl != NULL) 
203 {
204 if (ftype < GAXIS)
205 {
206 caxis * axis_hdl_ = (caxis *) axis_hdl; 
207 axis_hdl_->zvalue.setValue(zvalue_val); 
208 }
209 else
210 {
211 caxisgroup * axis_hdl_
212 = (caxisgroup *) axis_hdl; 
213 axis_hdl_->zvalue.setValue(zvalue_val); 
214 }
215 }
216 }
217 
218
219
220 void xios_set_field_name (void * field_hdl, int ftype , const char * name , const int * name_size)
221 {
222 
223 StdString name_valtemp; 
224 StdSize d, f = 0; 
225 if (*name_size != -1) 
226 { 
227 name_valtemp.append (name, *name_size); 
228 d = name_valtemp.find_first_not_of(' '); 
229 f = name_valtemp.find_last_not_of (' '); 
230 } 
231 StdString name_val = (*name_size != -1) ? name_valtemp.substr(d, f-d+1) : "" ; 
232 
233 if (field_hdl != NULL) 
234 {
235 if (ftype < GAXIS)
236 {
237 cfield * field_hdl_ = (cfield *) field_hdl; 
238 field_hdl_->name.setValue(name_val); 
239 }
240 else
241 {
242 cfieldgroup * field_hdl_
243 = (cfieldgroup *) field_hdl; 
244 field_hdl_->name.setValue(name_val); 
245 }
246 }
247 }
248 
249
250
251 void xios_set_field_standard_name (void * field_hdl, int ftype , const char * standard_name , const int * standard_name_size)
252 {
253 
254 StdString standard_name_valtemp; 
255 StdSize d, f = 0; 
256 if (*standard_name_size != -1) 
257 { 
258 standard_name_valtemp.append (standard_name, *standard_name_size); 
259 d = standard_name_valtemp.find_first_not_of(' '); 
260 f = standard_name_valtemp.find_last_not_of (' '); 
261 } 
262 StdString standard_name_val = (*standard_name_size != -1) ? standard_name_valtemp.substr(d, f-d+1) : "" ; 
263 
264 if (field_hdl != NULL) 
265 {
266 if (ftype < GAXIS)
267 {
268 cfield * field_hdl_ = (cfield *) field_hdl; 
269 field_hdl_->standard_name.setValue(standard_name_val); 
270 }
271 else
272 {
273 cfieldgroup * field_hdl_
274 = (cfieldgroup *) field_hdl; 
275 field_hdl_->standard_name.setValue(standard_name_val); 
276 }
277 }
278 }
279 
280
281
282 void xios_set_field_long_name (void * field_hdl, int ftype , const char * long_name , const int * long_name_size)
283 {
284 
285 StdString long_name_valtemp; 
286 StdSize d, f = 0; 
287 if (*long_name_size != -1) 
288 { 
289 long_name_valtemp.append (long_name, *long_name_size); 
290 d = long_name_valtemp.find_first_not_of(' '); 
291 f = long_name_valtemp.find_last_not_of (' '); 
292 } 
293 StdString long_name_val = (*long_name_size != -1) ? long_name_valtemp.substr(d, f-d+1) : "" ; 
294 
295 if (field_hdl != NULL) 
296 {
297 if (ftype < GAXIS)
298 {
299 cfield * field_hdl_ = (cfield *) field_hdl; 
300 field_hdl_->long_name.setValue(long_name_val); 
301 }
302 else
303 {
304 cfieldgroup * field_hdl_
305 = (cfieldgroup *) field_hdl; 
306 field_hdl_->long_name.setValue(long_name_val); 
307 }
308 }
309 }
310 
311
312
313 void xios_set_field_unit (void * field_hdl, int ftype , const char * unit , const int * unit_size)
314 {
315 
316 StdString unit_valtemp; 
317 StdSize d, f = 0; 
318 if (*unit_size != -1) 
319 { 
320 unit_valtemp.append (unit, *unit_size); 
321 d = unit_valtemp.find_first_not_of(' '); 
322 f = unit_valtemp.find_last_not_of (' '); 
323 } 
324 StdString unit_val = (*unit_size != -1) ? unit_valtemp.substr(d, f-d+1) : "" ; 
325 
326 if (field_hdl != NULL) 
327 {
328 if (ftype < GAXIS)
329 {
330 cfield * field_hdl_ = (cfield *) field_hdl; 
331 field_hdl_->unit.setValue(unit_val); 
332 }
333 else
334 {
335 cfieldgroup * field_hdl_
336 = (cfieldgroup *) field_hdl; 
337 field_hdl_->unit.setValue(unit_val); 
338 }
339 }
340 }
341 
342
343
344 void xios_set_field_operation (void * field_hdl, int ftype , const char * operation , const int * operation_size)
345 {
346 
347 StdString operation_valtemp; 
348 StdSize d, f = 0; 
349 if (*operation_size != -1) 
350 { 
351 operation_valtemp.append (operation, *operation_size); 
352 d = operation_valtemp.find_first_not_of(' '); 
353 f = operation_valtemp.find_last_not_of (' '); 
354 } 
355 StdString operation_val = (*operation_size != -1) ? operation_valtemp.substr(d, f-d+1) : "" ; 
356 
357 if (field_hdl != NULL) 
358 {
359 if (ftype < GAXIS)
360 {
361 cfield * field_hdl_ = (cfield *) field_hdl; 
362 field_hdl_->operation.setValue(operation_val); 
363 }
364 else
365 {
366 cfieldgroup * field_hdl_
367 = (cfieldgroup *) field_hdl; 
368 field_hdl_->operation.setValue(operation_val); 
369 }
370 }
371 }
372 
373
374
375 void xios_set_field_freq_op (void * field_hdl, int ftype , const char * freq_op , const int * freq_op_size)
376 {
377 
378 StdString freq_op_valtemp; 
379 StdSize d, f = 0; 
380 if (*freq_op_size != -1) 
381 { 
382 freq_op_valtemp.append (freq_op, *freq_op_size); 
383 d = freq_op_valtemp.find_first_not_of(' '); 
384 f = freq_op_valtemp.find_last_not_of (' '); 
385 } 
386 StdString freq_op_val = (*freq_op_size != -1) ? freq_op_valtemp.substr(d, f-d+1) : "" ; 
387 
388 if (field_hdl != NULL) 
389 {
390 if (ftype < GAXIS)
391 {
392 cfield * field_hdl_ = (cfield *) field_hdl; 
393 field_hdl_->freq_op.setValue(freq_op_val); 
394 }
395 else
396 {
397 cfieldgroup * field_hdl_
398 = (cfieldgroup *) field_hdl; 
399 field_hdl_->freq_op.setValue(freq_op_val); 
400 }
401 }
402 }
403 
404
405
406 void xios_set_field_level (void * field_hdl, int ftype , const int * level)
407 {
408 int level_val = *level; 
409 if (field_hdl != NULL) 
410 {
411 if (ftype < GAXIS)
412 {
413 cfield * field_hdl_ = (cfield *) field_hdl; 
414 field_hdl_->level.setValue(level_val); 
415 }
416 else
417 {
418 cfieldgroup * field_hdl_
419 = (cfieldgroup *) field_hdl; 
420 field_hdl_->level.setValue(level_val); 
421 }
422 }
423 }
424 
425
426
427 void xios_set_field_prec (void * field_hdl, int ftype , const int * prec)
428 {
429 int prec_val = *prec; 
430 if (field_hdl != NULL) 
431 {
432 if (ftype < GAXIS)
433 {
434 cfield * field_hdl_ = (cfield *) field_hdl; 
435 field_hdl_->prec.setValue(prec_val); 
436 }
437 else
438 {
439 cfieldgroup * field_hdl_
440 = (cfieldgroup *) field_hdl; 
441 field_hdl_->prec.setValue(prec_val); 
442 }
443 }
444 }
445 
446
447
448 void xios_set_field_enabled (void * field_hdl, int ftype , const bool * enabled)
449 {
450 bool enabled_val = *enabled; 
451 if (field_hdl != NULL) 
452 {
453 if (ftype < GAXIS)
454 {
455 cfield * field_hdl_ = (cfield *) field_hdl; 
456 field_hdl_->enabled.setValue(enabled_val); 
457 }
458 else
459 {
460 cfieldgroup * field_hdl_
461 = (cfieldgroup *) field_hdl; 
462 field_hdl_->enabled.setValue(enabled_val); 
463 }
464 }
465 }
466 
467
468
469 void xios_set_field_domain_ref (void * field_hdl, int ftype , const char * domain_ref , const int * domain_ref_size)
470 {
471 
472 StdString domain_ref_valtemp; 
473 StdSize d, f = 0; 
474 if (*domain_ref_size != -1) 
475 { 
476 domain_ref_valtemp.append (domain_ref, *domain_ref_size); 
477 d = domain_ref_valtemp.find_first_not_of(' '); 
478 f = domain_ref_valtemp.find_last_not_of (' '); 
479 } 
480 StdString domain_ref_val = (*domain_ref_size != -1) ? domain_ref_valtemp.substr(d, f-d+1) : "" ; 
481 
482 if (field_hdl != NULL) 
483 {
484 if (ftype < GAXIS)
485 {
486 cfield * field_hdl_ = (cfield *) field_hdl; 
487 field_hdl_->domain_ref.setValue(domain_ref_val); 
488 }
489 else
490 {
491 cfieldgroup * field_hdl_
492 = (cfieldgroup *) field_hdl; 
493 field_hdl_->domain_ref.setValue(domain_ref_val); 
494 }
495 }
496 }
497 
498
499
500 void xios_set_field_axis_ref (void * field_hdl, int ftype , const char * axis_ref , const int * axis_ref_size)
501 {
502 
503 StdString axis_ref_valtemp; 
504 StdSize d, f = 0; 
505 if (*axis_ref_size != -1) 
506 { 
507 axis_ref_valtemp.append (axis_ref, *axis_ref_size); 
508 d = axis_ref_valtemp.find_first_not_of(' '); 
509 f = axis_ref_valtemp.find_last_not_of (' '); 
510 } 
511 StdString axis_ref_val = (*axis_ref_size != -1) ? axis_ref_valtemp.substr(d, f-d+1) : "" ; 
512 
513 if (field_hdl != NULL) 
514 {
515 if (ftype < GAXIS)
516 {
517 cfield * field_hdl_ = (cfield *) field_hdl; 
518 field_hdl_->axis_ref.setValue(axis_ref_val); 
519 }
520 else
521 {
522 cfieldgroup * field_hdl_
523 = (cfieldgroup *) field_hdl; 
524 field_hdl_->axis_ref.setValue(axis_ref_val); 
525 }
526 }
527 }
528 
529
530
531 void xios_set_field_grid_ref (void * field_hdl, int ftype , const char * grid_ref , const int * grid_ref_size)
532 {
533 
534 StdString grid_ref_valtemp; 
535 StdSize d, f = 0; 
536 if (*grid_ref_size != -1) 
537 { 
538 grid_ref_valtemp.append (grid_ref, *grid_ref_size); 
539 d = grid_ref_valtemp.find_first_not_of(' '); 
540 f = grid_ref_valtemp.find_last_not_of (' '); 
541 } 
542 StdString grid_ref_val = (*grid_ref_size != -1) ? grid_ref_valtemp.substr(d, f-d+1) : "" ; 
543 
544 if (field_hdl != NULL) 
545 {
546 if (ftype < GAXIS)
547 {
548 cfield * field_hdl_ = (cfield *) field_hdl; 
549 field_hdl_->grid_ref.setValue(grid_ref_val); 
550 }
551 else
552 {
553 cfieldgroup * field_hdl_
554 = (cfieldgroup *) field_hdl; 
555 field_hdl_->grid_ref.setValue(grid_ref_val); 
556 }
557 }
558 }
559 
560
561
562 void xios_set_field_zoom_ref (void * field_hdl, int ftype , const char * zoom_ref , const int * zoom_ref_size)
563 {
564 
565 StdString zoom_ref_valtemp; 
566 StdSize d, f = 0; 
567 if (*zoom_ref_size != -1) 
568 { 
569 zoom_ref_valtemp.append (zoom_ref, *zoom_ref_size); 
570 d = zoom_ref_valtemp.find_first_not_of(' '); 
571 f = zoom_ref_valtemp.find_last_not_of (' '); 
572 } 
573 StdString zoom_ref_val = (*zoom_ref_size != -1) ? zoom_ref_valtemp.substr(d, f-d+1) : "" ; 
574 
575 if (field_hdl != NULL) 
576 {
577 if (ftype < GAXIS)
578 {
579 cfield * field_hdl_ = (cfield *) field_hdl; 
580 field_hdl_->zoom_ref.setValue(zoom_ref_val); 
581 }
582 else
583 {
584 cfieldgroup * field_hdl_
585 = (cfieldgroup *) field_hdl; 
586 field_hdl_->zoom_ref.setValue(zoom_ref_val); 
587 }
588 }
589 }
590 
591
592
593 void xios_set_field_field_ref (void * field_hdl, int ftype , const char * field_ref , const int * field_ref_size)
594 {
595 
596 StdString field_ref_valtemp; 
597 StdSize d, f = 0; 
598 if (*field_ref_size != -1) 
599 { 
600 field_ref_valtemp.append (field_ref, *field_ref_size); 
601 d = field_ref_valtemp.find_first_not_of(' '); 
602 f = field_ref_valtemp.find_last_not_of (' '); 
603 } 
604 StdString field_ref_val = (*field_ref_size != -1) ? field_ref_valtemp.substr(d, f-d+1) : "" ; 
605 
606 if (field_hdl != NULL) 
607 {
608 if (ftype < GAXIS)
609 {
610 cfield * field_hdl_ = (cfield *) field_hdl; 
611 field_hdl_->field_ref.setValue(field_ref_val); 
612 }
613 else
614 {
615 cfieldgroup * field_hdl_
616 = (cfieldgroup *) field_hdl; 
617 field_hdl_->field_ref.setValue(field_ref_val); 
618 }
619 }
620 }
621 
622
623
624 void xios_set_context_calendar_type (void * context_hdl, int ftype , const char * calendar_type , const int * calendar_type_size)
625 {
626 
627 StdString calendar_type_valtemp; 
628 StdSize d, f = 0; 
629 if (*calendar_type_size != -1) 
630 { 
631 calendar_type_valtemp.append (calendar_type, *calendar_type_size); 
632 d = calendar_type_valtemp.find_first_not_of(' '); 
633 f = calendar_type_valtemp.find_last_not_of (' '); 
634 } 
635 StdString calendar_type_val = (*calendar_type_size != -1) ? calendar_type_valtemp.substr(d, f-d+1) : "" ; 
636 
637 if (context_hdl != NULL) 
638 {
639 if (ftype < GAXIS)
640 {
641 ccontext * context_hdl_ = (ccontext *) context_hdl; 
642 context_hdl_->calendar_type.setValue(calendar_type_val); 
643 }
644 else
645 {
646 ccontextgroup * context_hdl_
647 = (ccontextgroup *) context_hdl; 
648 context_hdl_->calendar_type.setValue(calendar_type_val); 
649 }
650 }
651 }
652 
653
654
655 void xios_set_context_start_date (void * context_hdl, int ftype , const char * start_date , const int * start_date_size)
656 {
657 
658 StdString start_date_valtemp; 
659 StdSize d, f = 0; 
660 if (*start_date_size != -1) 
661 { 
662 start_date_valtemp.append (start_date, *start_date_size); 
663 d = start_date_valtemp.find_first_not_of(' '); 
664 f = start_date_valtemp.find_last_not_of (' '); 
665 } 
666 StdString start_date_val = (*start_date_size != -1) ? start_date_valtemp.substr(d, f-d+1) : "" ; 
667 
668 if (context_hdl != NULL) 
669 {
670 if (ftype < GAXIS)
671 {
672 ccontext * context_hdl_ = (ccontext *) context_hdl; 
673 context_hdl_->start_date.setValue(start_date_val); 
674 }
675 else
676 {
677 ccontextgroup * context_hdl_
678 = (ccontextgroup *) context_hdl; 
679 context_hdl_->start_date.setValue(start_date_val); 
680 }
681 }
682 }
683 
684
685
686 void xios_set_domain_name (void * domain_hdl, int ftype , const char * name , const int * name_size)
687 {
688 
689 StdString name_valtemp; 
690 StdSize d, f = 0; 
691 if (*name_size != -1) 
692 { 
693 name_valtemp.append (name, *name_size); 
694 d = name_valtemp.find_first_not_of(' '); 
695 f = name_valtemp.find_last_not_of (' '); 
696 } 
697 StdString name_val = (*name_size != -1) ? name_valtemp.substr(d, f-d+1) : "" ; 
698 
699 if (domain_hdl != NULL) 
700 {
701 if (ftype < GAXIS)
702 {
703 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
704 domain_hdl_->name.setValue(name_val); 
705 }
706 else
707 {
708 cdomaingroup * domain_hdl_
709 = (cdomaingroup *) domain_hdl; 
710 domain_hdl_->name.setValue(name_val); 
711 }
712 }
713 }
714 
715
716
717 void xios_set_domain_standard_name (void * domain_hdl, int ftype , const char * standard_name , const int * standard_name_size)
718 {
719 
720 StdString standard_name_valtemp; 
721 StdSize d, f = 0; 
722 if (*standard_name_size != -1) 
723 { 
724 standard_name_valtemp.append (standard_name, *standard_name_size); 
725 d = standard_name_valtemp.find_first_not_of(' '); 
726 f = standard_name_valtemp.find_last_not_of (' '); 
727 } 
728 StdString standard_name_val = (*standard_name_size != -1) ? standard_name_valtemp.substr(d, f-d+1) : "" ; 
729 
730 if (domain_hdl != NULL) 
731 {
732 if (ftype < GAXIS)
733 {
734 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
735 domain_hdl_->standard_name.setValue(standard_name_val); 
736 }
737 else
738 {
739 cdomaingroup * domain_hdl_
740 = (cdomaingroup *) domain_hdl; 
741 domain_hdl_->standard_name.setValue(standard_name_val); 
742 }
743 }
744 }
745 
746
747
748 void xios_set_domain_long_name (void * domain_hdl, int ftype , const char * long_name , const int * long_name_size)
749 {
750 
751 StdString long_name_valtemp; 
752 StdSize d, f = 0; 
753 if (*long_name_size != -1) 
754 { 
755 long_name_valtemp.append (long_name, *long_name_size); 
756 d = long_name_valtemp.find_first_not_of(' '); 
757 f = long_name_valtemp.find_last_not_of (' '); 
758 } 
759 StdString long_name_val = (*long_name_size != -1) ? long_name_valtemp.substr(d, f-d+1) : "" ; 
760 
761 if (domain_hdl != NULL) 
762 {
763 if (ftype < GAXIS)
764 {
765 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
766 domain_hdl_->long_name.setValue(long_name_val); 
767 }
768 else
769 {
770 cdomaingroup * domain_hdl_
771 = (cdomaingroup *) domain_hdl; 
772 domain_hdl_->long_name.setValue(long_name_val); 
773 }
774 }
775 }
776 
777
778
779 void xios_set_domain_ni_glo (void * domain_hdl, int ftype , const int * ni_glo)
780 {
781 int ni_glo_val = *ni_glo; 
782 if (domain_hdl != NULL) 
783 {
784 if (ftype < GAXIS)
785 {
786 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
787 domain_hdl_->ni_glo.setValue(ni_glo_val); 
788 }
789 else
790 {
791 cdomaingroup * domain_hdl_
792 = (cdomaingroup *) domain_hdl; 
793 domain_hdl_->ni_glo.setValue(ni_glo_val); 
794 }
795 }
796 }
797 
798
799
800 void xios_set_domain_nj_glo (void * domain_hdl, int ftype , const int * nj_glo)
801 {
802 int nj_glo_val = *nj_glo; 
803 if (domain_hdl != NULL) 
804 {
805 if (ftype < GAXIS)
806 {
807 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
808 domain_hdl_->nj_glo.setValue(nj_glo_val); 
809 }
810 else
811 {
812 cdomaingroup * domain_hdl_
813 = (cdomaingroup *) domain_hdl; 
814 domain_hdl_->nj_glo.setValue(nj_glo_val); 
815 }
816 }
817 }
818 
819
820
821 void xios_set_domain_ibegin (void * domain_hdl, int ftype , const int * ibegin)
822 {
823 int ibegin_val = *ibegin; 
824 if (domain_hdl != NULL) 
825 {
826 if (ftype < GAXIS)
827 {
828 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
829 domain_hdl_->ibegin.setValue(ibegin_val); 
830 }
831 else
832 {
833 cdomaingroup * domain_hdl_
834 = (cdomaingroup *) domain_hdl; 
835 domain_hdl_->ibegin.setValue(ibegin_val); 
836 }
837 }
838 }
839 
840
841
842 void xios_set_domain_iend (void * domain_hdl, int ftype , const int * iend)
843 {
844 int iend_val = *iend; 
845 if (domain_hdl != NULL) 
846 {
847 if (ftype < GAXIS)
848 {
849 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
850 domain_hdl_->iend.setValue(iend_val); 
851 }
852 else
853 {
854 cdomaingroup * domain_hdl_
855 = (cdomaingroup *) domain_hdl; 
856 domain_hdl_->iend.setValue(iend_val); 
857 }
858 }
859 }
860 
861
862
863 void xios_set_domain_ni (void * domain_hdl, int ftype , const int * ni)
864 {
865 int ni_val = *ni; 
866 if (domain_hdl != NULL) 
867 {
868 if (ftype < GAXIS)
869 {
870 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
871 domain_hdl_->ni.setValue(ni_val); 
872 }
873 else
874 {
875 cdomaingroup * domain_hdl_
876 = (cdomaingroup *) domain_hdl; 
877 domain_hdl_->ni.setValue(ni_val); 
878 }
879 }
880 }
881 
882
883
884 void xios_set_domain_jbegin (void * domain_hdl, int ftype , const int * jbegin)
885 {
886 int jbegin_val = *jbegin; 
887 if (domain_hdl != NULL) 
888 {
889 if (ftype < GAXIS)
890 {
891 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
892 domain_hdl_->jbegin.setValue(jbegin_val); 
893 }
894 else
895 {
896 cdomaingroup * domain_hdl_
897 = (cdomaingroup *) domain_hdl; 
898 domain_hdl_->jbegin.setValue(jbegin_val); 
899 }
900 }
901 }
902 
903
904
905 void xios_set_domain_jend (void * domain_hdl, int ftype , const int * jend)
906 {
907 int jend_val = *jend; 
908 if (domain_hdl != NULL) 
909 {
910 if (ftype < GAXIS)
911 {
912 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
913 domain_hdl_->jend.setValue(jend_val); 
914 }
915 else
916 {
917 cdomaingroup * domain_hdl_
918 = (cdomaingroup *) domain_hdl; 
919 domain_hdl_->jend.setValue(jend_val); 
920 }
921 }
922 }
923 
924
925
926 void xios_set_domain_nj (void * domain_hdl, int ftype , const int * nj)
927 {
928 int nj_val = *nj; 
929 if (domain_hdl != NULL) 
930 {
931 if (ftype < GAXIS)
932 {
933 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
934 domain_hdl_->nj.setValue(nj_val); 
935 }
936 else
937 {
938 cdomaingroup * domain_hdl_
939 = (cdomaingroup *) domain_hdl; 
940 domain_hdl_->nj.setValue(nj_val); 
941 }
942 }
943 }
944 
945
946
947 void xios_set_domain_mask (void * domain_hdl, int ftype , const bool * mask , const int * mask_extent1 , const int * mask_extent2)
948 {
949 int mask_extent1_val = *mask_extent1; 
950 int mask_extent2_val = *mask_extent2; 
951 boost::shared_ptr<CArray<bool, 2> > mask_val
952 (new CArray<bool, 2>(boost::extents [mask_extent1_val][mask_extent2_val])); 
953 std::copy(mask, &(mask[mask_val->num_elements()]), mask_val->data()); 
954 
955 if (domain_hdl != NULL) 
956 {
957 if (ftype < GAXIS)
958 {
959 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
960 domain_hdl_->mask.setValue(mask_val); 
961 }
962 else
963 {
964 cdomaingroup * domain_hdl_
965 = (cdomaingroup *) domain_hdl; 
966 domain_hdl_->mask.setValue(mask_val); 
967 }
968 }
969 }
970 
971
972
973 void xios_set_domain_data_dim (void * domain_hdl, int ftype , const int * data_dim)
974 {
975 int data_dim_val = *data_dim; 
976 if (domain_hdl != NULL) 
977 {
978 if (ftype < GAXIS)
979 {
980 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
981 domain_hdl_->data_dim.setValue(data_dim_val); 
982 }
983 else
984 {
985 cdomaingroup * domain_hdl_
986 = (cdomaingroup *) domain_hdl; 
987 domain_hdl_->data_dim.setValue(data_dim_val); 
988 }
989 }
990 }
991 
992
993
994 void xios_set_domain_data_ni (void * domain_hdl, int ftype , const int * data_ni)
995 {
996 int data_ni_val = *data_ni; 
997 if (domain_hdl != NULL) 
998 {
999 if (ftype < GAXIS)
1000 {
1001 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1002 domain_hdl_->data_ni.setValue(data_ni_val); 
1003 }
1004 else
1005 {
1006 cdomaingroup * domain_hdl_
1007 = (cdomaingroup *) domain_hdl; 
1008 domain_hdl_->data_ni.setValue(data_ni_val); 
1009 }
1010 }
1011 }
1012 
1013
1014
1015 void xios_set_domain_data_nj (void * domain_hdl, int ftype , const int * data_nj)
1016 {
1017 int data_nj_val = *data_nj; 
1018 if (domain_hdl != NULL) 
1019 {
1020 if (ftype < GAXIS)
1021 {
1022 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1023 domain_hdl_->data_nj.setValue(data_nj_val); 
1024 }
1025 else
1026 {
1027 cdomaingroup * domain_hdl_
1028 = (cdomaingroup *) domain_hdl; 
1029 domain_hdl_->data_nj.setValue(data_nj_val); 
1030 }
1031 }
1032 }
1033 
1034
1035
1036 void xios_set_domain_data_ibegin (void * domain_hdl, int ftype , const int * data_ibegin)
1037 {
1038 int data_ibegin_val = *data_ibegin; 
1039 if (domain_hdl != NULL) 
1040 {
1041 if (ftype < GAXIS)
1042 {
1043 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1044 domain_hdl_->data_ibegin.setValue(data_ibegin_val); 
1045 }
1046 else
1047 {
1048 cdomaingroup * domain_hdl_
1049 = (cdomaingroup *) domain_hdl; 
1050 domain_hdl_->data_ibegin.setValue(data_ibegin_val); 
1051 }
1052 }
1053 }
1054 
1055
1056
1057 void xios_set_domain_data_jbegin (void * domain_hdl, int ftype , const int * data_jbegin)
1058 {
1059 int data_jbegin_val = *data_jbegin; 
1060 if (domain_hdl != NULL) 
1061 {
1062 if (ftype < GAXIS)
1063 {
1064 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1065 domain_hdl_->data_jbegin.setValue(data_jbegin_val); 
1066 }
1067 else
1068 {
1069 cdomaingroup * domain_hdl_
1070 = (cdomaingroup *) domain_hdl; 
1071 domain_hdl_->data_jbegin.setValue(data_jbegin_val); 
1072 }
1073 }
1074 }
1075 
1076
1077
1078 void xios_set_domain_data_n_index (void * domain_hdl, int ftype , const int * data_n_index)
1079 {
1080 int data_n_index_val = *data_n_index; 
1081 if (domain_hdl != NULL) 
1082 {
1083 if (ftype < GAXIS)
1084 {
1085 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1086 domain_hdl_->data_n_index.setValue(data_n_index_val); 
1087 }
1088 else
1089 {
1090 cdomaingroup * domain_hdl_
1091 = (cdomaingroup *) domain_hdl; 
1092 domain_hdl_->data_n_index.setValue(data_n_index_val); 
1093 }
1094 }
1095 }
1096 
1097
1098
1099 void xios_set_domain_data_i_index (void * domain_hdl, int ftype , const int * data_i_index , const int * data_i_index_extent1)
1100 {
1101 int data_i_index_extent1_val = *data_i_index_extent1; 
1102 boost::shared_ptr<CArray<int, 1> > data_i_index_val
1103 (new CArray<int, 1>(boost::extents [data_i_index_extent1_val])); 
1104 std::copy(data_i_index, &(data_i_index[data_i_index_val->num_elements()]), data_i_index_val->data()); 
1105 
1106 if (domain_hdl != NULL) 
1107 {
1108 if (ftype < GAXIS)
1109 {
1110 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1111 domain_hdl_->data_i_index.setValue(data_i_index_val); 
1112 }
1113 else
1114 {
1115 cdomaingroup * domain_hdl_
1116 = (cdomaingroup *) domain_hdl; 
1117 domain_hdl_->data_i_index.setValue(data_i_index_val); 
1118 }
1119 }
1120 }
1121 
1122
1123
1124 void xios_set_domain_data_j_index (void * domain_hdl, int ftype , const int * data_j_index , const int * data_j_index_extent1)
1125 {
1126 int data_j_index_extent1_val = *data_j_index_extent1; 
1127 boost::shared_ptr<CArray<int, 1> > data_j_index_val
1128 (new CArray<int, 1>(boost::extents [data_j_index_extent1_val])); 
1129 std::copy(data_j_index, &(data_j_index[data_j_index_val->num_elements()]), data_j_index_val->data()); 
1130 
1131 if (domain_hdl != NULL) 
1132 {
1133 if (ftype < GAXIS)
1134 {
1135 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1136 domain_hdl_->data_j_index.setValue(data_j_index_val); 
1137 }
1138 else
1139 {
1140 cdomaingroup * domain_hdl_
1141 = (cdomaingroup *) domain_hdl; 
1142 domain_hdl_->data_j_index.setValue(data_j_index_val); 
1143 }
1144 }
1145 }
1146 
1147
1148
1149 void xios_set_domain_lonvalue (void * domain_hdl, int ftype , const double * lonvalue , const int * lonvalue_extent1)
1150 {
1151 int lonvalue_extent1_val = *lonvalue_extent1; 
1152 boost::shared_ptr<CArray<double, 1> > lonvalue_val
1153 (new CArray<double, 1>(boost::extents [lonvalue_extent1_val])); 
1154 std::copy(lonvalue, &(lonvalue[lonvalue_val->num_elements()]), lonvalue_val->data()); 
1155 
1156 if (domain_hdl != NULL) 
1157 {
1158 if (ftype < GAXIS)
1159 {
1160 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1161 domain_hdl_->lonvalue.setValue(lonvalue_val); 
1162 }
1163 else
1164 {
1165 cdomaingroup * domain_hdl_
1166 = (cdomaingroup *) domain_hdl; 
1167 domain_hdl_->lonvalue.setValue(lonvalue_val); 
1168 }
1169 }
1170 }
1171 
1172
1173
1174 void xios_set_domain_latvalue (void * domain_hdl, int ftype , const double * latvalue , const int * latvalue_extent1)
1175 {
1176 int latvalue_extent1_val = *latvalue_extent1; 
1177 boost::shared_ptr<CArray<double, 1> > latvalue_val
1178 (new CArray<double, 1>(boost::extents [latvalue_extent1_val])); 
1179 std::copy(latvalue, &(latvalue[latvalue_val->num_elements()]), latvalue_val->data()); 
1180 
1181 if (domain_hdl != NULL) 
1182 {
1183 if (ftype < GAXIS)
1184 {
1185 cdomain * domain_hdl_ = (cdomain *) domain_hdl; 
1186 domain_hdl_->latvalue.setValue(latvalue_val); 
1187 }
1188 else
1189 {
1190 cdomaingroup * domain_hdl_
1191 = (cdomaingroup *) domain_hdl; 
1192 domain_hdl_->latvalue.setValue(latvalue_val); 
1193 }
1194 }
1195 }
1196 
1197
1198
1199 void xios_set_file_name (void * file_hdl, int ftype , const char * name , const int * name_size)
1200 {
1201 
1202 StdString name_valtemp; 
1203 StdSize d, f = 0; 
1204 if (*name_size != -1) 
1205 { 
1206 name_valtemp.append (name, *name_size); 
1207 d = name_valtemp.find_first_not_of(' '); 
1208 f = name_valtemp.find_last_not_of (' '); 
1209 } 
1210 StdString name_val = (*name_size != -1) ? name_valtemp.substr(d, f-d+1) : "" ; 
1211 
1212 if (file_hdl != NULL) 
1213 {
1214 if (ftype < GAXIS)
1215 {
1216 cfile * file_hdl_ = (cfile *) file_hdl; 
1217 file_hdl_->name.setValue(name_val); 
1218 }
1219 else
1220 {
1221 cfilegroup * file_hdl_
1222 = (cfilegroup *) file_hdl; 
1223 file_hdl_->name.setValue(name_val); 
1224 }
1225 }
1226 }
1227 
1228
1229
1230 void xios_set_file_description (void * file_hdl, int ftype , const char * description , const int * description_size)
1231 {
1232 
1233 StdString description_valtemp; 
1234 StdSize d, f = 0; 
1235 if (*description_size != -1) 
1236 { 
1237 description_valtemp.append (description, *description_size); 
1238 d = description_valtemp.find_first_not_of(' '); 
1239 f = description_valtemp.find_last_not_of (' '); 
1240 } 
1241 StdString description_val = (*description_size != -1) ? description_valtemp.substr(d, f-d+1) : "" ; 
1242 
1243 if (file_hdl != NULL) 
1244 {
1245 if (ftype < GAXIS)
1246 {
1247 cfile * file_hdl_ = (cfile *) file_hdl; 
1248 file_hdl_->description.setValue(description_val); 
1249 }
1250 else
1251 {
1252 cfilegroup * file_hdl_
1253 = (cfilegroup *) file_hdl; 
1254 file_hdl_->description.setValue(description_val); 
1255 }
1256 }
1257 }
1258 
1259
1260
1261 void xios_set_file_output_freq (void * file_hdl, int ftype , const char * output_freq , const int * output_freq_size)
1262 {
1263 
1264 StdString output_freq_valtemp; 
1265 StdSize d, f = 0; 
1266 if (*output_freq_size != -1) 
1267 { 
1268 output_freq_valtemp.append (output_freq, *output_freq_size); 
1269 d = output_freq_valtemp.find_first_not_of(' '); 
1270 f = output_freq_valtemp.find_last_not_of (' '); 
1271 } 
1272 StdString output_freq_val = (*output_freq_size != -1) ? output_freq_valtemp.substr(d, f-d+1) : "" ; 
1273 
1274 if (file_hdl != NULL) 
1275 {
1276 if (ftype < GAXIS)
1277 {
1278 cfile * file_hdl_ = (cfile *) file_hdl; 
1279 file_hdl_->output_freq.setValue(output_freq_val); 
1280 }
1281 else
1282 {
1283 cfilegroup * file_hdl_
1284 = (cfilegroup *) file_hdl; 
1285 file_hdl_->output_freq.setValue(output_freq_val); 
1286 }
1287 }
1288 }
1289 
1290
1291
1292 void xios_set_file_output_level (void * file_hdl, int ftype , const int * output_level)
1293 {
1294 int output_level_val = *output_level; 
1295 if (file_hdl != NULL) 
1296 {
1297 if (ftype < GAXIS)
1298 {
1299 cfile * file_hdl_ = (cfile *) file_hdl; 
1300 file_hdl_->output_level.setValue(output_level_val); 
1301 }
1302 else
1303 {
1304 cfilegroup * file_hdl_
1305 = (cfilegroup *) file_hdl; 
1306 file_hdl_->output_level.setValue(output_level_val); 
1307 }
1308 }
1309 }
1310 
1311
1312
1313 void xios_set_file_enabled (void * file_hdl, int ftype , const bool * enabled)
1314 {
1315 bool enabled_val = *enabled; 
1316 if (file_hdl != NULL) 
1317 {
1318 if (ftype < GAXIS)
1319 {
1320 cfile * file_hdl_ = (cfile *) file_hdl; 
1321 file_hdl_->enabled.setValue(enabled_val); 
1322 }
1323 else
1324 {
1325 cfilegroup * file_hdl_
1326 = (cfilegroup *) file_hdl; 
1327 file_hdl_->enabled.setValue(enabled_val); 
1328 }
1329 }
1330 }
1331 
1332
1333
1334 void xios_set_grid_name (void * grid_hdl, int ftype , const char * name , const int * name_size)
1335 {
1336 
1337 StdString name_valtemp; 
1338 StdSize d, f = 0; 
1339 if (*name_size != -1) 
1340 { 
1341 name_valtemp.append (name, *name_size); 
1342 d = name_valtemp.find_first_not_of(' '); 
1343 f = name_valtemp.find_last_not_of (' '); 
1344 } 
1345 StdString name_val = (*name_size != -1) ? name_valtemp.substr(d, f-d+1) : "" ; 
1346 
1347 if (grid_hdl != NULL) 
1348 {
1349 if (ftype < GAXIS)
1350 {
1351 cgrid * grid_hdl_ = (cgrid *) grid_hdl; 
1352 grid_hdl_->name.setValue(name_val); 
1353 }
1354 else
1355 {
1356 cgridgroup * grid_hdl_
1357 = (cgridgroup *) grid_hdl; 
1358 grid_hdl_->name.setValue(name_val); 
1359 }
1360 }
1361 }
1362 
1363
1364
1365 void xios_set_grid_description (void * grid_hdl, int ftype , const char * description , const int * description_size)
1366 {
1367 
1368 StdString description_valtemp; 
1369 StdSize d, f = 0; 
1370 if (*description_size != -1) 
1371 { 
1372 description_valtemp.append (description, *description_size); 
1373 d = description_valtemp.find_first_not_of(' '); 
1374 f = description_valtemp.find_last_not_of (' '); 
1375 } 
1376 StdString description_val = (*description_size != -1) ? description_valtemp.substr(d, f-d+1) : "" ; 
1377 
1378 if (grid_hdl != NULL) 
1379 {
1380 if (ftype < GAXIS)
1381 {
1382 cgrid * grid_hdl_ = (cgrid *) grid_hdl; 
1383 grid_hdl_->description.setValue(description_val); 
1384 }
1385 else
1386 {
1387 cgridgroup * grid_hdl_
1388 = (cgridgroup *) grid_hdl; 
1389 grid_hdl_->description.setValue(description_val); 
1390 }
1391 }
1392 }
1393 
1394
1395
1396 void xios_set_grid_domain_ref (void * grid_hdl, int ftype , const char * domain_ref , const int * domain_ref_size)
1397 {
1398 
1399 StdString domain_ref_valtemp; 
1400 StdSize d, f = 0; 
1401 if (*domain_ref_size != -1) 
1402 { 
1403 domain_ref_valtemp.append (domain_ref, *domain_ref_size); 
1404 d = domain_ref_valtemp.find_first_not_of(' '); 
1405 f = domain_ref_valtemp.find_last_not_of (' '); 
1406 } 
1407 StdString domain_ref_val = (*domain_ref_size != -1) ? domain_ref_valtemp.substr(d, f-d+1) : "" ; 
1408 
1409 if (grid_hdl != NULL) 
1410 {
1411 if (ftype < GAXIS)
1412 {
1413 cgrid * grid_hdl_ = (cgrid *) grid_hdl; 
1414 grid_hdl_->domain_ref.setValue(domain_ref_val); 
1415 }
1416 else
1417 {
1418 cgridgroup * grid_hdl_
1419 = (cgridgroup *) grid_hdl; 
1420 grid_hdl_->domain_ref.setValue(domain_ref_val); 
1421 }
1422 }
1423 }
1424 
1425
1426
1427 void xios_set_grid_axis_ref (void * grid_hdl, int ftype , const char * axis_ref , const int * axis_ref_size)
1428 {
1429 
1430 StdString axis_ref_valtemp; 
1431 StdSize d, f = 0; 
1432 if (*axis_ref_size != -1) 
1433 { 
1434 axis_ref_valtemp.append (axis_ref, *axis_ref_size); 
1435 d = axis_ref_valtemp.find_first_not_of(' '); 
1436 f = axis_ref_valtemp.find_last_not_of (' '); 
1437 } 
1438 StdString axis_ref_val = (*axis_ref_size != -1) ? axis_ref_valtemp.substr(d, f-d+1) : "" ; 
1439 
1440 if (grid_hdl != NULL) 
1441 {
1442 if (ftype < GAXIS)
1443 {
1444 cgrid * grid_hdl_ = (cgrid *) grid_hdl; 
1445 grid_hdl_->axis_ref.setValue(axis_ref_val); 
1446 }
1447 else
1448 {
1449 cgridgroup * grid_hdl_
1450 = (cgridgroup *) grid_hdl; 
1451 grid_hdl_->axis_ref.setValue(axis_ref_val); 
1452 }
1453 }
1454 }
1455 
1456
1457void xios_handle_create (XPtr * const _ret, XDType _dtype, const XString _id, XSize _id_len)
1458{
1459   
1460 StdString __idtemp; 
1461 StdSize d, f = 0; 
1462 if (_id_len != -1) 
1463 { 
1464 __idtemp.append (_id, _id_len); 
1465 d = __idtemp.find_first_not_of(' '); 
1466 f = __idtemp.find_last_not_of (' '); 
1467 } 
1468 StdString __id = (_id_len != -1) ? __idtemp.substr(d, f-d+1) : "" ; 
1469
1470   switch(_dtype)
1471   {
1472      case (ECONTEXT):
1473         *_ret = (!CObjectFactory::HasObject<CContext>(__id))
1474               ? 0 : CObjectFactory::GetObject<CContext>(__id).get();
1475         return ;
1476      case (EAXIS):
1477 { 
1478 *_ret = (!CObjectFactory::HasObject<CAxis>(__id))
1479 ? 0 : CObjectFactory::GetObject<CAxis>(__id).get(); 
1480 return; 
1481}
1482 case (GAXIS):
1483 { 
1484 *_ret = (!CObjectFactory::HasObject<CAxisGroup>(__id))
1485 ? 0 : CObjectFactory::GetObject<CAxisGroup>(__id).get(); 
1486 return; 
1487}
1488
1489      case (EDOMAIN):
1490 { 
1491 *_ret = (!CObjectFactory::HasObject<CDomain>(__id))
1492 ? 0 : CObjectFactory::GetObject<CDomain>(__id).get(); 
1493 return; 
1494}
1495 case (GDOMAIN):
1496 { 
1497 *_ret = (!CObjectFactory::HasObject<CDomainGroup>(__id))
1498 ? 0 : CObjectFactory::GetObject<CDomainGroup>(__id).get(); 
1499 return; 
1500}
1501
1502      case (EFIELD):
1503 { 
1504 *_ret = (!CObjectFactory::HasObject<CField>(__id))
1505 ? 0 : CObjectFactory::GetObject<CField>(__id).get(); 
1506 return; 
1507}
1508 case (GFIELD):
1509 { 
1510 *_ret = (!CObjectFactory::HasObject<CFieldGroup>(__id))
1511 ? 0 : CObjectFactory::GetObject<CFieldGroup>(__id).get(); 
1512 return; 
1513}
1514
1515      case (EFILE):
1516 { 
1517 *_ret = (!CObjectFactory::HasObject<CFile>(__id))
1518 ? 0 : CObjectFactory::GetObject<CFile>(__id).get(); 
1519 return; 
1520}
1521 case (GFILE):
1522 { 
1523 *_ret = (!CObjectFactory::HasObject<CFileGroup>(__id))
1524 ? 0 : CObjectFactory::GetObject<CFileGroup>(__id).get(); 
1525 return; 
1526}
1527
1528      case (EGRID):
1529 { 
1530 *_ret = (!CObjectFactory::HasObject<CGrid>(__id))
1531 ? 0 : CObjectFactory::GetObject<CGrid>(__id).get(); 
1532 return; 
1533}
1534 case (GGRID):
1535 { 
1536 *_ret = (!CObjectFactory::HasObject<CGridGroup>(__id))
1537 ? 0 : CObjectFactory::GetObject<CGridGroup>(__id).get(); 
1538 return; 
1539}
1540
1541      default :
1542         *_ret = 0;
1543         return;
1544   }
1545}
1546void xios_xml_parse_file (const XString _filename, XSize _filename_len)
1547{
1548   try
1549   {
1550     
1551 StdString __filenametemp; 
1552 StdSize d, f = 0; 
1553 if (_filename_len != -1) 
1554 { 
1555 __filenametemp.append (_filename, _filename_len); 
1556 d = __filenametemp.find_first_not_of(' '); 
1557 f = __filenametemp.find_last_not_of (' '); 
1558 } 
1559 StdString __filename = (_filename_len != -1) ? __filenametemp.substr(d, f-d+1) : "" ; ;
1560      CTreeManager::ParseFile(__filename);
1561      StdOStringStream oss;
1562      oss << StdString("data/def/def_client_pre.")
1563          << CMPIManager::GetCommRank(CMPIManager::GetCommWorld());
1564      CTreeManager::PrintTreeToFile(oss.str());
1565   }
1566   catch (CException & exc)
1567   {
1568      std::cerr << exc.getMessage() << std::endl;
1569      exit (EXIT_FAILURE);
1570   }
1571}
1572void xios_xml_parse_string(const XString _xmlcontent, XSize _xmlcontent_len)
1573{
1574   try
1575   {
1576     
1577 StdString __xmlcontenttemp; 
1578 StdSize d, f = 0; 
1579 if (_xmlcontent_len != -1) 
1580 { 
1581 __xmlcontenttemp.append (_xmlcontent, _xmlcontent_len); 
1582 d = __xmlcontenttemp.find_first_not_of(' '); 
1583 f = __xmlcontenttemp.find_last_not_of (' '); 
1584 } 
1585 StdString __xmlcontent = (_xmlcontent_len != -1) ? __xmlcontenttemp.substr(d, f-d+1) : "" ; ;
1586      CTreeManager::ParseString(__xmlcontent);
1587      StdOStringStream oss;
1588      oss << StdString("data/def/def_client_pre.")
1589          << CMPIManager::GetCommRank(CMPIManager::GetCommWorld());
1590      CTreeManager::PrintTreeToFile(oss.str());
1591   }
1592   catch (CException & exc)
1593   {
1594      std::cerr << exc.getMessage() << std::endl;
1595      exit (EXIT_FAILURE);
1596   }
1597}
1598void xios_context_set_current (XPtr const _ctx, bool _wswap)
1599{
1600   boost::shared_ptr<CContext> context = CObjectFactory::GetObject<CContext> ((CContext*)_ctx);
1601   CTreeManager::SetCurrentContextId(context->getId());
1602}
1603void xios_context_create (XPtr * _ctxt, const XString _ctxt_id,
1604                          XSize _ctxt_id_len, XCalendarType _calType,
1605                          XInt yr, XInt mth, XInt dd,
1606                          XInt hr, XInt min, XInt sec)
1607{
1608   try
1609   {
1610     
1611 StdString __ctxt_idtemp; 
1612 StdSize d, f = 0; 
1613 if (_ctxt_id_len != -1) 
1614 { 
1615 __ctxt_idtemp.append (_ctxt_id, _ctxt_id_len); 
1616 d = __ctxt_idtemp.find_first_not_of(' '); 
1617 f = __ctxt_idtemp.find_last_not_of (' '); 
1618 } 
1619 StdString __ctxt_id = (_ctxt_id_len != -1) ? __ctxt_idtemp.substr(d, f-d+1) : "" ; ;
1620      boost::shared_ptr<CContext> context = CTreeManager::CreateContext(__ctxt_id);
1621      *_ctxt = context.get();
1622   }
1623   catch (CException & exc)
1624   {
1625      std::cerr << exc.getMessage() << std::endl;
1626      exit (EXIT_FAILURE);
1627   }
1628}
1629void xios_xml_tree_add(const XPtr _parent, XDType _parent_type, XPtr * _child,
1630                       XDType _child_type, const XString _child_id, XSize _child_id_len)
1631{
1632   
1633 StdString __child_idtemp; 
1634 StdSize d, f = 0; 
1635 if (_child_id_len != -1) 
1636 { 
1637 __child_idtemp.append (_child_id, _child_id_len); 
1638 d = __child_idtemp.find_first_not_of(' '); 
1639 f = __child_idtemp.find_last_not_of (' '); 
1640 } 
1641 StdString __child_id = (_child_id_len != -1) ? __child_idtemp.substr(d, f-d+1) : "" ; 
1642
1643   try
1644   {
1645      switch (_parent_type)
1646      {
1647         case (EFILE) :
1648         {
1649            CFile * _file = (CFile *) _parent;
1650            boost::shared_ptr<CFile> file = CObjectFactory::GetObject<CFile>(_file);
1651            if (!CObjectFactory::HasObject<CFieldGroup>(file->getId()))
1652               file->setVirtualFieldGroup(file->getId());
1653            xios_xml_tree_add (file->getVirtualFieldGroup().get(), GFIELD,
1654                              _child, EFIELD, _child_id, _child_id_len);
1655            return;
1656         }
1657         case (GAXIS) :
1658 { 
1659 CAxisGroup * _group = (CAxisGroup *) _parent; boost::shared_ptr<CAxisGroup> group = 
1660 CObjectFactory::GetObject<CAxisGroup>(_group); 
1661 switch(_child_type) 
1662 { 
1663 case (GAXIS) :
1664 if ((_child_id_len != -1) && 
1665 (CObjectFactory::HasObject<CAxisGroup>(__child_id))) 
1666 return; 
1667 *_child = CGroupFactory::CreateGroup(group, __child_id).get(); 
1668 break; 
1669 case (EAXIS) :
1670 if ((_child_id_len != -1) && 
1671 (CObjectFactory::HasObject<CAxis>(__child_id))) 
1672 return; 
1673 *_child = CGroupFactory::CreateChild(group, __child_id).get(); 
1674 break; 
1675 default : 
1676 std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; 
1677 }; 
1678 return; 
1679 };
1680         case (GGRID) :
1681 { 
1682 CGridGroup * _group = (CGridGroup *) _parent; boost::shared_ptr<CGridGroup> group = 
1683 CObjectFactory::GetObject<CGridGroup>(_group); 
1684 switch(_child_type) 
1685 { 
1686 case (GGRID) :
1687 if ((_child_id_len != -1) && 
1688 (CObjectFactory::HasObject<CGridGroup>(__child_id))) 
1689 return; 
1690 *_child = CGroupFactory::CreateGroup(group, __child_id).get(); 
1691 break; 
1692 case (EGRID) :
1693 if ((_child_id_len != -1) && 
1694 (CObjectFactory::HasObject<CGrid>(__child_id))) 
1695 return; 
1696 *_child = CGroupFactory::CreateChild(group, __child_id).get(); 
1697 break; 
1698 default : 
1699 std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; 
1700 }; 
1701 return; 
1702 };
1703         case (GDOMAIN) :
1704 { 
1705 CDomainGroup * _group = (CDomainGroup *) _parent; boost::shared_ptr<CDomainGroup> group = 
1706 CObjectFactory::GetObject<CDomainGroup>(_group); 
1707 switch(_child_type) 
1708 { 
1709 case (GDOMAIN) :
1710 if ((_child_id_len != -1) && 
1711 (CObjectFactory::HasObject<CDomainGroup>(__child_id))) 
1712 return; 
1713 *_child = CGroupFactory::CreateGroup(group, __child_id).get(); 
1714 break; 
1715 case (EDOMAIN) :
1716 if ((_child_id_len != -1) && 
1717 (CObjectFactory::HasObject<CDomain>(__child_id))) 
1718 return; 
1719 *_child = CGroupFactory::CreateChild(group, __child_id).get(); 
1720 break; 
1721 default : 
1722 std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; 
1723 }; 
1724 return; 
1725 };
1726         case (GFIELD) :
1727 { 
1728 CFieldGroup * _group = (CFieldGroup *) _parent; boost::shared_ptr<CFieldGroup> group = 
1729 CObjectFactory::GetObject<CFieldGroup>(_group); 
1730 switch(_child_type) 
1731 { 
1732 case (GFIELD) :
1733 if ((_child_id_len != -1) && 
1734 (CObjectFactory::HasObject<CFieldGroup>(__child_id))) 
1735 return; 
1736 *_child = CGroupFactory::CreateGroup(group, __child_id).get(); 
1737 break; 
1738 case (EFIELD) :
1739 if ((_child_id_len != -1) && 
1740 (CObjectFactory::HasObject<CField>(__child_id))) 
1741 return; 
1742 *_child = CGroupFactory::CreateChild(group, __child_id).get(); 
1743 break; 
1744 default : 
1745 std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; 
1746 }; 
1747 return; 
1748 };
1749         case (GFILE) :
1750 { 
1751 CFileGroup * _group = (CFileGroup *) _parent; boost::shared_ptr<CFileGroup> group = 
1752 CObjectFactory::GetObject<CFileGroup>(_group); 
1753 switch(_child_type) 
1754 { 
1755 case (GFILE) :
1756 if ((_child_id_len != -1) && 
1757 (CObjectFactory::HasObject<CFileGroup>(__child_id))) 
1758 return; 
1759 *_child = CGroupFactory::CreateGroup(group, __child_id).get(); 
1760 break; 
1761 case (EFILE) :
1762 if ((_child_id_len != -1) && 
1763 (CObjectFactory::HasObject<CFile>(__child_id))) 
1764 return; 
1765 *_child = CGroupFactory::CreateChild(group, __child_id).get(); 
1766 break; 
1767 default : 
1768 std::cerr << "[xml_tree_add] Type enfant invalide" << std::endl; 
1769 }; 
1770 return; 
1771 };
1772         default :
1773            std::cerr << "[xml_tree_add] Type parent invalide" << std::endl;
1774            return;
1775      }
1776   }
1777   catch (CException & exc)
1778   {
1779      std::cerr << exc.getMessage() << std::endl;
1780      exit (EXIT_FAILURE);
1781   }
1782}
1783void xios_xml_tree_show(const XString _filename, XSize _filename_len)
1784{
1785   
1786 StdString __filenametemp; 
1787 StdSize d, f = 0; 
1788 if (_filename_len != -1) 
1789 { 
1790 __filenametemp.append (_filename, _filename_len); 
1791 d = __filenametemp.find_first_not_of(' '); 
1792 f = __filenametemp.find_last_not_of (' '); 
1793 } 
1794 StdString __filename = (_filename_len != -1) ? __filenametemp.substr(d, f-d+1) : "" ; 
1795
1796   if (_filename_len != -1)
1797      CTreeManager::PrintTreeToFile(__filename);
1798   else
1799      CTreeManager::PrintTreeToStream(std::clog);
1800}
1801void xios_dtreatment_start(XPtr const _context, XFileType filetype)
1802{
1803   try
1804   {
1805      StdOStringStream oss;
1806      oss << StdString("data/def/def_client_next.")
1807          << CMPIManager::GetCommRank(CMPIManager::GetCommWorld());
1808      CTreeManager::PrintTreeToFile(oss.str());
1809      CDataTreatment dt;
1810      dt.createDataOutput<CNc4DataOutput>();
1811      oss.str("");
1812      oss << StdString("data/def/def_client_end.")
1813          << CMPIManager::GetCommRank(CMPIManager::GetCommWorld());
1814      CTreeManager::PrintTreeToFile(oss.str());
1815   }
1816   catch (CException & exc)
1817   {
1818      std::cerr << exc.getMessage() << std::endl;
1819      exit (EXIT_FAILURE);
1820   }
1821}
1822void xios_dtreatment_end(void)
1823{
1824}
1825void xios_write_data(const XString _field_id, XSize _field_id_len, double * data_k8,
1826                     XSize data_Xsize, XSize data_Ysize, XSize data_Zsize)
1827{
1828}
1829void xios_update_calendar(int step)
1830{
1831}
1832void xios_set_timestep(double ts_year, double ts_month, double ts_day,
1833                       double ts_hour, double ts_minute, double ts_second)
1834{
1835}
1836}
Note: See TracBrowser for help on using the repository browser.