src/MEDLoader/Swig/MEDLoaderTypemaps.i

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (EDF R&D)
  20
  21 #include <vector>
  22
  23 static PyObject *convertMEDFileMesh(MEDCoupling::MEDFileMesh* mesh, int owner) throw(INTERP_KERNEL::Exception)
  24 {
  25   PyObject *ret=0;
  26   if(!mesh)
  27     {
  28       Py_XINCREF(Py_None);
  29       return Py_None;
  30     }
  31   if(dynamic_cast<MEDCoupling::MEDFileUMesh *>(mesh))
  32     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDFileUMesh,owner);
  33   if(dynamic_cast<MEDCoupling::MEDFileCMesh *>(mesh))
  34     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDFileCMesh,owner);
  35   if(dynamic_cast<MEDCoupling::MEDFileCurveLinearMesh *>(mesh))
  36     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDFileCurveLinearMesh,owner);
  37   if(!ret)
  38     throw INTERP_KERNEL::Exception("Not recognized type of MEDFileMesh on downcast !");
  39   return ret;
  40 }
  41
  42 static PyObject *convertMEDFileParameter1TS(MEDCoupling::MEDFileParameter1TS* p1ts, int owner) throw(INTERP_KERNEL::Exception)
  43 {
  44   PyObject *ret=0;
  45   if(!p1ts)
  46     {
  47       Py_XINCREF(Py_None);
  48       return Py_None;
  49     }
  50   if(dynamic_cast<MEDFileParameterDouble1TS *>(p1ts))
  51     ret=SWIG_NewPointerObj((void*)p1ts,SWIGTYPE_p_MEDCoupling__MEDFileParameterDouble1TS,owner);
  52   if(dynamic_cast<MEDFileParameterDouble1TSWTI *>(p1ts))
  53     ret=SWIG_NewPointerObj((void*)p1ts,SWIGTYPE_p_MEDCoupling__MEDFileParameterDouble1TSWTI,owner);
  54   if(!ret)
  55     throw INTERP_KERNEL::Exception("Not recognized type of MEDFileParameter1TS on downcast !");
  56   return ret;
  57 }
  58
  59 static PyObject *convertMEDFileField1TS(MEDCoupling::MEDFileAnyTypeField1TS *p, int owner) throw(INTERP_KERNEL::Exception)
  60 {
  61   PyObject *ret=0;
  62   if(!p)
  63     {
  64       Py_XINCREF(Py_None);
  65       return Py_None;
  66     }
  67   if(dynamic_cast<MEDFileField1TS *>(p))
  68     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileField1TS,owner);
  69   if(dynamic_cast<MEDFileIntField1TS *>(p))
  70     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileIntField1TS,owner);
  71   if(dynamic_cast<MEDFileFloatField1TS *>(p))
  72     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileFloatField1TS,owner);
  73   if(!ret)
  74     throw INTERP_KERNEL::Exception("Not recognized type of MEDFileAnyTypeField1TS on downcast !");
  75   return ret;
  76 }
  77
  78 static PyObject *convertMEDFileFieldMultiTS(MEDCoupling::MEDFileAnyTypeFieldMultiTS *p, int owner) throw(INTERP_KERNEL::Exception)
  79 {
  80   PyObject *ret=0;
  81   if(!p)
  82     {
  83       Py_XINCREF(Py_None);
  84       return Py_None;
  85     }
  86   if(dynamic_cast<MEDFileFieldMultiTS *>(p))
  87     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileFieldMultiTS,owner);
  88   if(dynamic_cast<MEDFileIntFieldMultiTS *>(p))
  89     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileIntFieldMultiTS,owner);
  90   if(dynamic_cast<MEDFileFloatFieldMultiTS *>(p))
  91     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDFileFloatFieldMultiTS,owner);
  92   if(!ret)
  93     throw INTERP_KERNEL::Exception("Not recognized type of MEDFileAnyTypeFieldMultiTS on downcast !");
  94   return ret;
  95 }
  96
  97 static PyObject *convertMEDMeshMultiLev(MEDCoupling::MEDMeshMultiLev *p, int owner) throw(INTERP_KERNEL::Exception)
  98 {
  99   PyObject *ret=0;
 100   if(!p)
 101     {
 102       Py_XINCREF(Py_None);
 103       return Py_None;
 104     }
 105   if(dynamic_cast<MEDUMeshMultiLev *>(p))
 106     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDUMeshMultiLev,owner);
 107   if(dynamic_cast<MEDCMeshMultiLev *>(p))
 108     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDCMeshMultiLev,owner);
 109   if(dynamic_cast<MEDCurveLinearMeshMultiLev *>(p))
 110     ret=SWIG_NewPointerObj((void*)p,SWIGTYPE_p_MEDCoupling__MEDCurveLinearMeshMultiLev,owner);
 111   if(!ret)
 112     throw INTERP_KERNEL::Exception("Not recognized type of MEDMeshMultiLev on downcast !");
 113   return ret;
 114 }
 115
 116 static std::vector<std::pair<int,int> > convertTimePairIdsFromPy(PyObject *pyLi) throw(INTERP_KERNEL::Exception)
 117 {
 118   std::vector<std::pair<int,int> > ret;
 119   if(PyList_Check(pyLi))
 120     {
 121       int size=PyList_Size(pyLi);
 122       ret.resize(size);
 123       for(int i=0;i<size;i++)
 124         {
 125           PyObject *o=PyList_GetItem(pyLi,i);
 126           if(PyTuple_Check(o))
 127             {
 128               std::pair<int,int> p;
 129               int size2=PyTuple_Size(o);
 130               if(size2!=2)
 131                 throw INTERP_KERNEL::Exception("tuples in list must be of size 2 (dt,it) !");
 132               PyObject *o0=PyTuple_GetItem(o,0);
 133               if(PyInt_Check(o0))
 134                 p.first=(int)PyInt_AS_LONG(o0);
 135               else
 136                 throw INTERP_KERNEL::Exception("First elem of tuples in list must be integer : dt !");
 137               PyObject *o1=PyTuple_GetItem(o,1);
 138               if(PyInt_Check(o1))
 139                 p.second=(int)PyInt_AS_LONG(o1);
 140               else
 141                 throw INTERP_KERNEL::Exception("Second elem of tuples in list must be integer : dt !");
 142               ret[i]=p;
 143             }
 144           else
 145             throw INTERP_KERNEL::Exception("list must contain tuples only");
 146         }
 147     }
 148   else
 149     throw INTERP_KERNEL::Exception("convertTimePairIdsFromPy : not a list");
 150   return ret;
 151 }
 152
 153 static std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > convertVecPairIntToVecPairTOFCT(const std::vector<std::pair<int,int> >& tmp)
 154 {
 155   std::size_t sz(tmp.size());
 156   std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > entitiesCpp(sz);
 157   for(std::size_t i=0;i<sz;i++)
 158     {
 159       entitiesCpp[i].first=(TypeOfField)tmp[i].first;
 160       entitiesCpp[i].second=(INTERP_KERNEL::NormalizedCellType)tmp[i].second;
 161     }
 162   return entitiesCpp;
 163 }
 164
 165 static void converPyListToVecString(PyObject *pyLi, std::vector<std::string>& v)
 166 {
 167   static const char msg0[]="In list passed in argument some elements are NOT strings ! Expected a list containing only strings !";
 168   static const char msg1[]="In tuple passed in argument some elements are NOT strings ! Expected a list containing only strings !";
 169   static const char msg2[]="Unrecognized python argument : expected a list of string or tuple of string or string !";
 170   if(PyList_Check(pyLi))
 171     {
 172       int size=PyList_Size(pyLi);
 173       v.resize(size);
 174       for(int i=0;i<size;i++)
 175         {
 176           PyObject *o=PyList_GetItem(pyLi,i);
 177           v[i]=convertPyObjectToStr(o,msg0);
 178         }
 179       return ;
 180     }
 181   else if(PyTuple_Check(pyLi))
 182     {
 183       int size=PyTuple_Size(pyLi);
 184       v.resize(size);
 185       for(int i=0;i<size;i++)
 186         {
 187           PyObject *o=PyTuple_GetItem(pyLi,i);
 188           v[i]=convertPyObjectToStr(o,msg1);
 189         }
 190       return ;
 191     }
 192   v.resize(1);
 193   v[0]=convertPyObjectToStr(pyLi,msg2);
 194 }
 195
 196 static PyObject *convertFieldDoubleVecToPy(const std::vector<MEDCoupling::MEDCouplingFieldDouble *>& li)
 197 {
 198   int sz=li.size();
 199   PyObject *ret=PyList_New(sz);
 200   for(int i=0;i<sz;i++)
 201     {
 202       PyObject *o=SWIG_NewPointerObj((void*)li[i],SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,SWIG_POINTER_OWN | 0);
 203       PyList_SetItem(ret,i,o);
 204     }
 205   return ret;
 206 }
 207
 208 PyObject *convertVecPairIntToPy(const std::vector< std::pair<int,int> >& vec)
 209 {
 210   PyObject *ret(PyList_New(vec.size()));
 211   int rk=0;
 212   for(std::vector< std::pair<int,int> >::const_iterator iter=vec.begin();iter!=vec.end();iter++,rk++)
 213     {
 214       PyObject *elt=PyTuple_New(2);
 215       PyTuple_SetItem(elt,0,SWIG_From_int((*iter).first));
 216       PyTuple_SetItem(elt,1,SWIG_From_int((*iter).second));
 217       PyList_SetItem(ret,rk,elt);
 218     }
 219   return ret;
 220 }
 221
 222 PyObject *convertVecPairVecStToPy(const std::vector< std::pair<std::vector<std::string>, std::string > >& vec)
 223 {
 224   int sz=(int)vec.size();
 225   PyObject *ret=PyList_New(sz);
 226   for(int i=0;i<sz;i++)
 227     {
 228       PyObject *t=PyTuple_New(2);
 229       int sz2=(int)vec[i].first.size();
 230       PyObject *ll=PyList_New(sz2);
 231       for(int j=0;j<sz2;j++)
 232         PyList_SetItem(ll,j,PyString_FromString(vec[i].first[j].c_str()));
 233       PyTuple_SetItem(t,0,ll);
 234       PyTuple_SetItem(t,1,PyString_FromString(vec[i].second.c_str()));
 235       PyList_SetItem(ret,i,t);
 236     }
 237   return ret;
 238 }
 239
 240 PyObject *convertVectPairStToPy(const std::vector< std::pair<std::string, std::string > >& vec)
 241 {
 242   int sz=(int)vec.size();
 243   PyObject *ret=PyList_New(sz);
 244   for(int i=0;i<sz;i++)
 245     {
 246       PyObject *t=PyTuple_New(2);
 247       PyTuple_SetItem(t,0,PyString_FromString(vec[i].first.c_str()));
 248       PyTuple_SetItem(t,1,PyString_FromString(vec[i].second.c_str()));
 249       PyList_SetItem(ret,i,t);
 250     }
 251   return ret;
 252 }
 253
 254 std::vector< std::pair<std::string, std::string > > convertVecPairStStFromPy(PyObject *pyLi)
 255 {
 256   std::vector< std::pair<std::string, std::string > > ret;
 257   const char *msg="convertVecPairStStFromPy : Expecting PyList of Tuples of size 2 ! The first elt in tuple is one string and the 2nd one a string !";
 258   if(PyList_Check(pyLi))
 259     {
 260       int size=PyList_Size(pyLi);
 261       ret.resize(size);
 262       for(int i=0;i<size;i++)
 263         {
 264           PyObject *o=PyList_GetItem(pyLi,i);
 265           if(PyTuple_Check(o))
 266             {
 267               std::pair<std::string, std::string> p;
 268               int size2=PyTuple_Size(o);
 269               if(size2!=2)
 270                 throw INTERP_KERNEL::Exception(msg);
 271               PyObject *o0=PyTuple_GetItem(o,0);
 272               p.first=convertPyObjectToStr(o0,msg);
 273               PyObject *o1=PyTuple_GetItem(o,1);
 274               p.second=convertPyObjectToStr(o1,msg);
 275               ret[i]=p;
 276             }
 277           else
 278             throw INTERP_KERNEL::Exception(msg);
 279         }
 280       return ret;
 281     }
 282   throw INTERP_KERNEL::Exception(msg);
 283 }
 284
 285 std::vector< std::pair<std::vector<std::string>, std::string > > convertVecPairVecStFromPy(PyObject *pyLi)
 286 {
 287   std::vector< std::pair<std::vector<std::string>, std::string > > ret;
 288   const char *msg="convertVecPairVecStFromPy : Expecting PyList of Tuples of size 2 ! The first elt in tuple is a list of strings and the 2nd one a string !";
 289   if(PyList_Check(pyLi))
 290     {
 291       int size=PyList_Size(pyLi);
 292       ret.resize(size);
 293       for(int i=0;i<size;i++)
 294         {
 295           PyObject *o=PyList_GetItem(pyLi,i);
 296           if(PyTuple_Check(o))
 297             {
 298               std::pair<std::vector<std::string>, std::string> p;
 299               int size2=PyTuple_Size(o);
 300               if(size2!=2)
 301                 throw INTERP_KERNEL::Exception(msg);
 302               PyObject *o0=PyTuple_GetItem(o,0);
 303               if(PyList_Check(o0))
 304                 {
 305                   int size3=PyList_Size(o0);
 306                   p.first.resize(size3);
 307                   for(int j=0;j<size3;j++)
 308                     {
 309                       PyObject *o0j=PyList_GetItem(o0,j);
 310                       p.first[j]=convertPyObjectToStr(o0j,msg);
 311                     }
 312                 }
 313               else
 314                 throw INTERP_KERNEL::Exception(msg);
 315               PyObject *o1=PyTuple_GetItem(o,1);
 316               p.second=convertPyObjectToStr(o1,msg);
 317               ret[i]=p;
 318             }
 319           else
 320             throw INTERP_KERNEL::Exception(msg);
 321         }
 322       return ret;
 323     }
 324   throw INTERP_KERNEL::Exception(msg);
 325 }
 326
 327 /*!
 328  * Called by MEDFileAnyTypeFieldMultiTS::__getitem__ when \a elt0 is neither a list nor a slice.
 329  * In this case a MEDFileAnyTypeField1TS object is returned.
 330  */
 331 int MEDFileAnyTypeFieldMultiTSgetitemSingleTS__(const MEDFileAnyTypeFieldMultiTS *self, PyObject *elt0) throw(INTERP_KERNEL::Exception)
 332 {
 333   if(elt0 && PyInt_Check(elt0))
 334     {//fmts[3]
 335       return InterpreteNegativeInt(PyInt_AS_LONG(elt0),self->getNumberOfTS());
 336     }
 337   else if(elt0 && PyTuple_Check(elt0))
 338     {
 339       if(PyTuple_Size(elt0)==2)
 340         {
 341           PyObject *o0=PyTuple_GetItem(elt0,0);
 342           PyObject *o1=PyTuple_GetItem(elt0,1);
 343           if(PyInt_Check(o0) && PyInt_Check(o1))
 344             {//fmts(1,-1)
 345               int iter=PyInt_AS_LONG(o0);
 346               int order=PyInt_AS_LONG(o1);
 347               return self->getPosOfTimeStep(iter,order);
 348             }
 349           else
 350             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::__getitem__ : invalid input param ! input is a tuple of size 2 but two integers are expected in this tuple to request a time steps !");
 351         }
 352       else
 353         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::__getitem__ : invalid input param ! input is a tuple of size != 2 ! two integers are expected in this tuple to request a time steps !");
 354     }
 355   else if(elt0 && PyFloat_Check(elt0))
 356     {
 357       double val=PyFloat_AS_DOUBLE(elt0);
 358       return self->getPosGivenTime(val);
 359     }
 360   else
 361     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::__getitem__ : invalid input params ! expected fmts[int], fmts[int,int], or fmts[double] to request one time step ! To request a series of time steps invoke fmts[slice], fmts[list of int], fmts[list of double], or fmts[list of int,int] !");
 362 }
 363
 364 /*!
 365  * Called by MEDFileAnyTypeFieldMultiTS::__getitem__ when \a obj is neither a list nor a slice.
 366  * In this case a MEDFileAnyTypeField1TS object is returned.
 367  */
 368 int MEDFileFieldsgetitemSingleTS__(const MEDFileFields *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 369 {
 370   static const char msg[]="MEDFileFields::__getitem__ : only integer or string with fieldname supported !";
 371   if(PyInt_Check(obj))
 372     {
 373       return InterpreteNegativeInt((int)PyInt_AS_LONG(obj),self->getNumberOfFields());
 374     }
 375   return self->getPosFromFieldName(convertPyObjectToStr(obj,msg));
 376 }
 377
 378 void convertToMapIntDataArrayInt(PyObject *pyMap, std::map<int, MCAuto<DataArrayInt> >& cppMap)
 379 {
 380   if(!PyDict_Check(pyMap))
 381     throw INTERP_KERNEL::Exception("convertToMapIntDataArrayInt : input is not a python map !");
 382   PyObject *key, *value;
 383   Py_ssize_t pos(0);
 384   cppMap.clear();
 385   while (PyDict_Next(pyMap,&pos,&key,&value))
 386     {
 387       if(!PyInt_Check(key))
 388         throw INTERP_KERNEL::Exception("convertToMapIntDataArrayInt : keys in map must be PyInt !");
 389       long k(PyInt_AS_LONG(key));
 390       void *argp(0);
 391       int status(SWIG_ConvertPtr(value,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0));
 392       if(!SWIG_IsOK(status))
 393         {
 394           std::ostringstream oss; oss << "convertToMapIntDataArrayInt : values in map must be DataArrayInt !";
 395           throw INTERP_KERNEL::Exception(oss.str().c_str());
 396         }
 397       DataArrayInt *arg(reinterpret_cast<DataArrayInt*>(argp));
 398       MCAuto<DataArrayInt> arg2(arg);
 399       if(arg)
 400         arg->incrRef();
 401       cppMap[k]=arg2;
 402     }
 403 }
 404
 405 template<class T>
 406 PyObject *MEDFileField1TS_getFieldWithProfile(const typename MLFieldTraits<T>::F1TSType *self, TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh)
 407 {
 408   DataArrayInt *ret1(NULL);
 409   typename MEDCoupling::Traits<T>::ArrayType *ret0(self->getFieldWithProfile(type,meshDimRelToMax,mesh,ret1));
 410   PyObject *ret(PyTuple_New(2));
 411   PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits<T>::TI, SWIG_POINTER_OWN | 0 ));
 412   PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
 413   return ret;
 414 }
 415