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

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