source: XIOS/trunk/src/interface/c/icxml_tree.cpp @ 836

Last change on this file since 836 was 836, checked in by mhnguyen, 8 years ago

Exposing transformation to Fortran interface

+) Export zoom and axis transformation to Fortran interface

Test
+) On Curie
+) All work

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:eol-style set to native
File size: 15.5 KB
Line 
1/* ************************************************************************** *
2 *      Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7
8#include "xios.hpp"
9
10#include "attribute_template.hpp"
11#include "object_template.hpp"
12#include "group_template.hpp"
13
14#include "icutil.hpp"
15#include "timer.hpp"
16#include "context.hpp"
17#include "grid.hpp"
18#include "file.hpp"
19#include "field.hpp"
20#include "axis.hpp"
21#include "domain.hpp"
22#include "variable.hpp"
23#include "zoom_domain.hpp"
24#include "interpolate_domain.hpp"
25#include "generate_rectilinear_domain.hpp"
26#include "zoom_axis.hpp"
27#include "interpolate_axis.hpp"
28#include "inverse_axis.hpp"
29
30extern "C"
31{
32// /////////////////////////////// Définitions ////////////////////////////// //
33
34   // ----------------------- Redéfinition de types ----------------------------
35
36   typedef xios::CContext * XContextPtr;
37
38   typedef xios::CGrid      * XGridPtr;
39   typedef xios::CGridGroup * XGridGroupPtr;
40
41   typedef xios::CFile      * XFilePtr;
42   typedef xios::CFileGroup * XFileGroupPtr;
43
44   typedef xios::CField      * XFieldPtr;
45   typedef xios::CFieldGroup * XFieldGroupPtr;
46
47   typedef xios::CDomain      * XDomainPtr;
48   typedef xios::CDomainGroup * XDomainGroupPtr;
49
50   typedef xios::CAxis      * XAxisPtr;
51   typedef xios::CAxisGroup * XAxisGroupPtr;
52
53   typedef xios::CVariable      *  XVariablePtr;
54   typedef xios::CVariableGroup *  XVariableGroupPtr;
55
56   typedef xios::CTransformation<CDomain>   *  XTransformationDomainPtr;
57   typedef xios::CZoomDomain                *  XZoomDomainPtr;
58   typedef xios::CInterpolateDomain         *  XInterpolateDomainPtr;
59   typedef xios::CGenerateRectilinearDomain *  XGenerateRectilinearDomainPtr;
60
61   typedef xios::CTransformation<CAxis>   *  XTransformationAxisPtr;
62   typedef xios::CZoomAxis                *  XZoomAxisPtr;
63   typedef xios::CInterpolateAxis         *  XInterpolateAxisPtr;
64   typedef xios::CInverseAxis             *  XInverseAxisPtr;
65
66   // ----------------------- Ajout d'enfant à un parent -----------------------
67
68   void cxios_xml_tree_add_field
69      (XFieldGroupPtr  parent_, XFieldPtr * child_, const char * child_id, int child_id_size)
70   {
71      std::string child_id_str;
72      CTimer::get("XIOS").resume() ;
73      if (cstr2string(child_id, child_id_size, child_id_str))
74      {
75         *child_ = parent_->createChild(child_id_str) ;
76      }
77      else
78      {
79         *child_ = parent_->createChild() ;
80      }
81      CTimer::get("XIOS").suspend() ;
82  }
83
84   void cxios_xml_tree_add_grid
85      (XGridGroupPtr   parent_, XGridPtr * child_, const char * child_id, int child_id_size)
86   {
87      std::string child_id_str;
88      CTimer::get("XIOS").resume() ;
89      if (cstr2string(child_id, child_id_size, child_id_str))
90      {
91         *child_ = parent_->createChild(child_id_str) ;
92      }
93      else
94      {
95         *child_ = parent_->createChild() ;
96      }
97      CTimer::get("XIOS").suspend() ;
98   }
99
100   void cxios_xml_tree_add_file
101      (XFileGroupPtr parent_, XFilePtr * child_, const char * child_id, int child_id_size)
102   {
103      std::string child_id_str;
104      CTimer::get("XIOS").resume() ;
105      if (cstr2string(child_id, child_id_size, child_id_str))
106      {
107         *child_ = parent_->createChild(child_id_str) ;
108      }
109      else
110      {
111         *child_ = parent_->createChild() ;
112      }
113      CTimer::get("XIOS").suspend() ;
114   }
115
116   void cxios_xml_tree_add_axis
117      (XAxisGroupPtr parent_, XAxisPtr * child_, const char * child_id, int child_id_size)
118   {
119      std::string child_id_str;
120      CTimer::get("XIOS").resume() ;
121      if (cstr2string(child_id, child_id_size, child_id_str))
122      {
123         *child_ = parent_->createChild(child_id_str) ;
124      }
125      else
126      {
127         *child_ = parent_->createChild() ;
128      }
129      CTimer::get("XIOS").suspend() ;
130   }
131
132   void cxios_xml_tree_add_domain
133      (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size)
134   {
135      std::string child_id_str;
136      CTimer::get("XIOS").resume() ;
137      if (cstr2string(child_id, child_id_size, child_id_str))
138      {
139         *child_ = parent_->createChild(child_id_str) ;
140      }
141      else
142      {
143         *child_ = parent_->createChild() ;
144      }
145      CTimer::get("XIOS").suspend() ;
146   }
147
148   void cxios_xml_tree_add_fieldtofile
149      (XFilePtr parent_, XFieldPtr * child_, const char * child_id, int child_id_size)
150   {
151      std::string child_id_str;
152      CTimer::get("XIOS").resume() ;
153
154      if (cstr2string(child_id, child_id_size, child_id_str))
155      {
156         *child_ = parent_->addField(child_id_str);
157      }
158      else
159      {
160         *child_ = parent_->addField();
161      }
162      CTimer::get("XIOS").suspend() ;
163   }
164
165   void cxios_xml_tree_add_variabletofile
166      (XFilePtr parent_, XVariablePtr * child_, const char * child_id, int child_id_size)
167   {
168      std::string child_id_str;
169      CTimer::get("XIOS").resume() ;
170
171      if (cstr2string(child_id, child_id_size, child_id_str))
172      {
173         *child_ = parent_->addVariable(child_id_str);
174      }
175      else
176      {
177         *child_ = parent_->addVariable();
178      }
179      CTimer::get("XIOS").suspend() ;
180   }
181
182    void cxios_xml_tree_add_variabletofield
183      (XFieldPtr parent_, XVariablePtr * child_, const char * child_id, int child_id_size)
184   {
185      std::string child_id_str;
186      CTimer::get("XIOS").resume() ;
187
188      if (cstr2string(child_id, child_id_size, child_id_str))
189      {
190         *child_ = parent_->addVariable(child_id_str);
191      }
192      else
193      {
194         *child_ = parent_->addVariable();
195      }
196      CTimer::get("XIOS").suspend() ;
197   }
198   // ----------------------- Ajout de groupe à un parent ----------------------
199
200   void cxios_xml_tree_add_fieldgroup
201      (XFieldGroupPtr  parent_, XFieldGroupPtr * child_, const char * child_id, int child_id_size)
202   {
203     std::string child_id_str;
204      CTimer::get("XIOS").resume() ;
205      if (cstr2string(child_id, child_id_size, child_id_str))
206      {
207         *child_ = parent_->createChildGroup(child_id_str) ;
208      }
209      else
210      {
211         *child_ = parent_->createChildGroup() ;
212      }
213      CTimer::get("XIOS").suspend() ;
214   }
215
216   void cxios_xml_tree_add_gridgroup
217      (XGridGroupPtr   parent_, XGridGroupPtr * child_, const char * child_id, int child_id_size)
218   {
219      std::string child_id_str;
220      CTimer::get("XIOS").resume() ;
221      if (cstr2string(child_id, child_id_size, child_id_str))
222      {
223         *child_ = parent_->createChildGroup(child_id_str) ;
224      }
225      else
226      {
227         *child_ = parent_->createChildGroup() ;
228      }
229      CTimer::get("XIOS").suspend() ;
230   }
231
232   void cxios_xml_tree_add_filegroup
233      (XFileGroupPtr parent_, XFileGroupPtr * child_, const char * child_id, int child_id_size)
234   {
235      std::string child_id_str;
236      CTimer::get("XIOS").resume() ;
237      if (cstr2string(child_id, child_id_size, child_id_str))
238      {
239         *child_ = parent_->createChildGroup(child_id_str) ;
240      }
241      else
242      {
243         *child_ = parent_->createChildGroup() ;
244      }
245      CTimer::get("XIOS").suspend() ;
246   }
247
248   void cxios_xml_tree_add_axisgroup
249      (XAxisGroupPtr parent_, XAxisGroupPtr * child_, const char * child_id, int child_id_size)
250   {
251      std::string child_id_str;
252      CTimer::get("XIOS").resume() ;
253      if (cstr2string(child_id, child_id_size, child_id_str))
254      {
255         *child_ = parent_->createChildGroup(child_id_str) ;
256      }
257      else
258      {
259         *child_ = parent_->createChildGroup() ;
260      }
261      CTimer::get("XIOS").suspend() ;
262   }
263
264   void cxios_xml_tree_add_domaingroup
265      (XDomainGroupPtr parent_, XDomainGroupPtr * child_, const char * child_id, int child_id_size)
266   {
267      std::string child_id_str;
268      CTimer::get("XIOS").resume() ;
269      if (cstr2string(child_id, child_id_size, child_id_str))
270      {
271         *child_ = parent_->createChildGroup(child_id_str) ;
272      }
273      else
274      {
275         *child_ = parent_->createChildGroup() ;
276      }
277      CTimer::get("XIOS").suspend() ;
278   }
279
280   void cxios_xml_tree_add_fieldgrouptofile
281      (XFilePtr parent_, XFieldGroupPtr * child_, const char * child_id, int child_id_size)
282   {
283      std::string child_id_str;
284      CTimer::get("XIOS").resume() ;
285      if (cstr2string(child_id, child_id_size, child_id_str))
286      {
287         *child_ = parent_->addFieldGroup(child_id_str);
288      }
289      else
290      {
291         *child_ = parent_->addFieldGroup();
292      }
293      CTimer::get("XIOS").suspend() ;
294   }
295
296   void cxios_xml_tree_add_variablegrouptofile
297      (XFilePtr parent_, XVariableGroupPtr * child_, const char * child_id, int child_id_size)
298   {
299      std::string child_id_str;
300      CTimer::get("XIOS").resume() ;
301      if (cstr2string(child_id, child_id_size, child_id_str))
302      {
303         *child_ = parent_->addVariableGroup(child_id_str);
304      }
305      else
306      {
307         *child_ = parent_->addVariableGroup();
308      }
309      CTimer::get("XIOS").suspend() ;
310   }
311
312   void cxios_xml_tree_add_variablegrouptofield
313      (XFieldPtr parent_, XVariableGroupPtr * child_, const char * child_id, int child_id_size)
314   {
315      std::string child_id_str;
316      CTimer::get("XIOS").resume() ;
317      if (cstr2string(child_id, child_id_size, child_id_str))
318      {
319         *child_ = parent_->addVariableGroup(child_id_str);
320      }
321      else
322      {
323         *child_ = parent_->addVariableGroup();
324      }
325      CTimer::get("XIOS").suspend() ;
326   }
327
328   void cxios_xml_tree_add_axistogrid
329      (XGridPtr parent_, XAxisPtr * child_, const char * child_id, int child_id_size)
330   {
331      std::string child_id_str;
332      CTimer::get("XIOS").resume() ;
333      if (cstr2string(child_id, child_id_size, child_id_str))
334      {
335         *child_ = parent_->addAxis(child_id_str);
336      }
337      else
338      {
339         *child_ = parent_->addAxis();
340      }
341      CTimer::get("XIOS").suspend() ;
342   }
343
344   void cxios_xml_tree_add_domaintogrid
345      (XGridPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size)
346   {
347      std::string child_id_str;
348      CTimer::get("XIOS").resume() ;
349      if (cstr2string(child_id, child_id_size, child_id_str))
350      {
351         *child_ = parent_->addDomain(child_id_str);
352      }
353      else
354      {
355         *child_ = parent_->addDomain();
356      }
357      CTimer::get("XIOS").suspend() ;
358   }
359
360   void cxios_xml_tree_add_zoomdomaintodomain
361      (XDomainPtr parent_, XZoomDomainPtr * child_, const char * child_id, int child_id_size)
362   {
363      std::string child_id_str;
364      XTransformationDomainPtr tmpChild_;
365      CTimer::get("XIOS").resume() ;
366      if (cstr2string(child_id, child_id_size, child_id_str))
367      {
368         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN, child_id_str);
369      }
370      else
371      {
372         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_DOMAIN);
373      }
374      *child_ = static_cast<XZoomDomainPtr>(tmpChild_);
375      CTimer::get("XIOS").suspend() ;
376   }
377
378   void cxios_xml_tree_add_interpolatedomaintodomain
379      (XDomainPtr parent_, XInterpolateDomainPtr * child_, const char * child_id, int child_id_size)
380   {
381      std::string child_id_str;
382      XTransformationDomainPtr tmpChild_;
383      CTimer::get("XIOS").resume() ;
384      if (cstr2string(child_id, child_id_size, child_id_str))
385      {
386         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN, child_id_str);
387      }
388      else
389      {
390         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_DOMAIN);
391      }
392      *child_ = static_cast<XInterpolateDomainPtr>(tmpChild_);
393      CTimer::get("XIOS").suspend() ;
394   }
395
396   void cxios_xml_tree_add_generatedomaintodomain
397      (XDomainPtr parent_, XGenerateRectilinearDomainPtr * child_, const char * child_id, int child_id_size)
398   {
399      std::string child_id_str;
400      XTransformationDomainPtr tmpChild_;
401      CTimer::get("XIOS").resume() ;
402      if (cstr2string(child_id, child_id_size, child_id_str))
403      {
404         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, child_id_str);
405      }
406      else
407      {
408         tmpChild_ = parent_->addTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN);
409      }
410      *child_ = static_cast<XGenerateRectilinearDomainPtr>(tmpChild_);
411      CTimer::get("XIOS").suspend() ;
412   }
413
414   void cxios_xml_tree_add_zoomaxistoaxis
415      (XAxisPtr parent_, XZoomAxisPtr * child_, const char * child_id, int child_id_size)
416   {
417      std::string child_id_str;
418      XTransformationAxisPtr tmpChild_;
419      CTimer::get("XIOS").resume() ;
420      if (cstr2string(child_id, child_id_size, child_id_str))
421      {
422         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS, child_id_str);
423      }
424      else
425      {
426         tmpChild_ = parent_->addTransformation(TRANS_ZOOM_AXIS);
427      }
428      *child_ = static_cast<XZoomAxisPtr>(tmpChild_);
429      CTimer::get("XIOS").suspend() ;
430   }
431
432   void cxios_xml_tree_add_interpolateaxistoaxis
433      (XAxisPtr parent_, XInterpolateAxisPtr * child_, const char * child_id, int child_id_size)
434   {
435      std::string child_id_str;
436      XTransformationAxisPtr tmpChild_;
437      CTimer::get("XIOS").resume() ;
438      if (cstr2string(child_id, child_id_size, child_id_str))
439      {
440         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS, child_id_str);
441      }
442      else
443      {
444         tmpChild_ = parent_->addTransformation(TRANS_INTERPOLATE_AXIS);
445      }
446      *child_ = static_cast<XInterpolateAxisPtr>(tmpChild_);
447      CTimer::get("XIOS").suspend() ;
448   }
449
450   void cxios_xml_tree_add_inverseaxistoaxis
451      (XAxisPtr parent_, XInverseAxisPtr * child_, const char * child_id, int child_id_size)
452   {
453      std::string child_id_str;
454      XTransformationAxisPtr tmpChild_;
455      CTimer::get("XIOS").resume() ;
456      if (cstr2string(child_id, child_id_size, child_id_str))
457      {
458         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS, child_id_str);
459      }
460      else
461      {
462         tmpChild_ = parent_->addTransformation(TRANS_INVERSE_AXIS);
463      }
464      *child_ = static_cast<XInverseAxisPtr>(tmpChild_);
465      CTimer::get("XIOS").suspend() ;
466   }
467
468   // ----------------------- Affichage de l'arborescence ----------------------
469
470//   void cxios_xml_tree_show   (const char * filename, int filename_size)
471//   {
472//      std::string filename_str;
473//      try
474//      {
475//         if (cstr2string(filename, filename_size, filename_str))
476//            xios::CTreeManager::PrintTreeToFile(filename_str);
477//         else
478//            xios::CTreeManager::PrintTreeToStream(std::clog);
479//      }
480//      catch (xios::CException & exc)
481//      {
482//         std::cerr << exc.getMessage() << std::endl;
483//         exit (EXIT_FAILURE);
484//      }
485//  }
486
487
488   // ----------------------- Parsing de document xml --------------------------
489
490//   void cxios_xml_parse_file  (const char * filename  , int filename_size)//
491//   {
492//      std::string filename_str;
493//      if (!cstr2string(filename, filename_size, filename_str)) return;
494//
495//      try
496//      {
497//         xios::CTreeManager::ParseFile(filename_str);
498//      }
499//      catch (xios::CException & exc)
500//      {
501//         std::cerr << exc.getMessage() << std::endl;
502//         exit (EXIT_FAILURE);
503//      }
504//   }
505
506//   void cxios_xml_parse_string(const char * xmlcontent, int xmlcontent_size)
507//   {
508//      std::string xmlcontent_str;
509//      if (!cstr2string(xmlcontent, xmlcontent_size, xmlcontent_str)) return;
510//
511//      try
512//      {
513//         xios::CTreeManager::ParseString(xmlcontent_str);
514//      }
515//      catch (xios::CException & exc)
516//      {
517//         std::cerr << exc.getMessage() << std::endl;
518//         exit (EXIT_FAILURE);
519//      }
520//   }
521
522
523
524} // extern "C"
Note: See TracBrowser for help on using the repository browser.