src/MEDCouplingCorba_Swig/Client/MEDCouplingClient.i

   1 // Copyright (C) 2007-2014  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 (CEA/DEN)
  20
  21 %module MEDCouplingClient
  22
  23 %{
  24 #include "MEDCouplingFieldDoubleClient.hxx"
  25 #include "MEDCouplingFieldTemplateClient.hxx"
  26 #include "MEDCouplingMultiFieldsClient.hxx"
  27 #include "MEDCouplingFieldOverTimeClient.hxx"
  28 #include "MEDCouplingUMeshClient.hxx"
  29 #include "MEDCoupling1SGTUMeshClient.hxx"
  30 #include "MEDCoupling1DGTUMeshClient.hxx"
  31 #include "MEDCouplingExtrudedMeshClient.hxx"
  32 #include "MEDCouplingCMeshClient.hxx"
  33 #include "MEDCouplingIMeshClient.hxx"
  34 #include "MEDCouplingCurveLinearMeshClient.hxx"
  35 #include "DataArrayDoubleClient.hxx"
  36 #include "DataArrayIntClient.hxx"
  37
  38 #include <iostream>
  39
  40 using namespace ParaMEDMEM;
  41 %}
  42
  43 %include "MEDCouplingCommon.i"
  44
  45 %newobject ParaMEDMEM::MEDCouplingFieldDoubleClient::New;
  46 %newobject ParaMEDMEM::MEDCouplingFieldTemplateClient::New;
  47 %newobject ParaMEDMEM::MEDCouplingUMeshClient::New;
  48 %newobject ParaMEDMEM::MEDCoupling1SGTUMeshClient::New;
  49 %newobject ParaMEDMEM::MEDCoupling1DGTUMeshClient::New;
  50 %newobject ParaMEDMEM::MEDCouplingExtrudedMeshClient::New;
  51 %newobject ParaMEDMEM::MEDCouplingCMeshClient::New;
  52 %newobject ParaMEDMEM::MEDCouplingIMeshClient::New;
  53 %newobject ParaMEDMEM::MEDCouplingCurveLinearMeshClient::New;
  54 %newobject ParaMEDMEM::MEDCouplingMultiFieldsClient::New;
  55 %newobject ParaMEDMEM::MEDCouplingFieldOverTimeClient::New;
  56 %newobject ParaMEDMEM::DataArrayDoubleClient::New;
  57 %newobject ParaMEDMEM::DataArrayIntClient::New;
  58
  59 %nodefaultctor;
  60 %nodefaultdtor;
  61
  62 namespace ParaMEDMEM
  63 {
  64   class MEDCouplingFieldDoubleClient
  65   {
  66   public:
  67     %extend
  68       {
  69         static MEDCouplingFieldDouble *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
  70         {
  71           PyObject* pdict=PyDict_New();
  72           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
  73           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
  74           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
  75           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
  76           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
  77           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
  78           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
  79           if(!iorField)
  80             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldDoubleClient.New appears to differ from CORBA reference ! Expecting a FieldDouble CORBA reference !");
  81           char *ior=PyString_AsString(iorField);
  82           int argc=0;
  83           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
  84           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
  85           SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldDoubleCorbaInterface::_narrow(fieldPtrCpp);
  86           if(CORBA::is_nil(fieldPtrCppC))
  87             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldDoubleCorbaInterface_ptr !");
  88           Py_DECREF(pdict);
  89           Py_DECREF(iorField);
  90           MEDCouplingFieldDouble *ret=MEDCouplingFieldDoubleClient::New(fieldPtrCppC);
  91           return ret;
  92         }
  93       }
  94   };
  95
  96   class MEDCouplingFieldTemplateClient
  97   {
  98   public:
  99     %extend
 100       {
 101         static MEDCouplingFieldTemplate *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
 102         {
 103           PyObject* pdict=PyDict_New();
 104           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 105           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 106           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 107           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 108           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 109           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 110           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 111           if(!iorField)
 112             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldTemplateClient.New appears to differ from CORBA reference ! Expecting a FieldTemplate CORBA reference !");
 113           char *ior=PyString_AsString(iorField);
 114           int argc=0;
 115           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 116           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 117           SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldTemplateCorbaInterface::_narrow(fieldPtrCpp);
 118           if(CORBA::is_nil(fieldPtrCppC))
 119             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldTemplateCorbaInterface_ptr !");
 120           Py_DECREF(pdict);
 121           Py_DECREF(iorField);
 122           MEDCouplingFieldTemplate *ret=MEDCouplingFieldTemplateClient::New(fieldPtrCppC);
 123           return ret;
 124         }
 125       }
 126   };
 127
 128   class MEDCouplingMultiFieldsClient
 129   {
 130   public:
 131     %extend
 132       {
 133         static MEDCouplingMultiFields *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
 134         {
 135           PyObject* pdict=PyDict_New();
 136           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 137           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 138           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 139           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 140           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 141           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 142           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 143           if(!iorField)
 144             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldTemplateClient.New appears to differ from CORBA reference ! Expecting a MultiFields CORBA reference !");
 145           char *ior=PyString_AsString(iorField);
 146           int argc=0;
 147           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 148           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 149           SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingMultiFieldsCorbaInterface::_narrow(fieldPtrCpp);
 150           if(CORBA::is_nil(fieldPtrCppC))
 151             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingMultiFieldsCorbaInterface_ptr !");
 152           Py_DECREF(pdict);
 153           Py_DECREF(iorField);
 154           MEDCouplingMultiFields *ret=MEDCouplingMultiFieldsClient::New(fieldPtrCppC);
 155           return ret;
 156         }
 157       }
 158   };
 159
 160   class MEDCouplingFieldOverTimeClient : public MEDCouplingFieldOverTime
 161   {
 162   public:
 163     std::vector<double> getTimeSteps() const;
 164     %extend
 165       {
 166         static MEDCouplingFieldOverTimeClient *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
 167         {
 168           PyObject* pdict=PyDict_New();
 169           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 170           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 171           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 172           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 173           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 174           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 175           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 176           if(!iorField)
 177             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldOverTimeClient.New appears to differ from CORBA reference ! Expecting a FieldOverTime CORBA reference !");
 178           char *ior=PyString_AsString(iorField);
 179           int argc=0;
 180           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 181           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 182           SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface::_narrow(fieldPtrCpp);
 183           if(CORBA::is_nil(fieldPtrCppC))
 184             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldOverTimeCorbaInterface_ptr !");
 185           Py_DECREF(pdict);
 186           Py_DECREF(iorField);
 187           MEDCouplingFieldOverTimeClient *ret=MEDCouplingFieldOverTimeClient::New(fieldPtrCppC);
 188           return ret;
 189         }
 190       }
 191   };
 192
 193   class MEDCouplingMeshClient
 194   {
 195   public:
 196     %extend
 197       {
 198         static MEDCouplingMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 199         {
 200           PyObject* pdict=PyDict_New();
 201           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 202           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 203           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 204           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 205           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 206           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 207           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 208           if(!iorMesh)
 209             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingMeshClient.New appears to differ from CORBA reference ! Expecting a MeshCorbaInterface CORBA reference !");
 210           char *ior=PyString_AsString(iorMesh);
 211           int argc=0;
 212           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 213           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 214           SALOME_MED::MEDCouplingUMeshCorbaInterface_var meshPtrCppC1=SALOME_MED::MEDCouplingUMeshCorbaInterface::_narrow(meshPtrCpp);
 215           if(!CORBA::is_nil(meshPtrCppC1))
 216             {
 217               Py_DECREF(pdict);
 218               Py_DECREF(iorMesh);
 219               return MEDCouplingUMeshClient::New(meshPtrCppC1);
 220             }
 221           SALOME_MED::MEDCouplingCMeshCorbaInterface_var meshPtrCppC2=SALOME_MED::MEDCouplingCMeshCorbaInterface::_narrow(meshPtrCpp);
 222           if(!CORBA::is_nil(meshPtrCppC2))
 223             {
 224               Py_DECREF(pdict);
 225               Py_DECREF(iorMesh);
 226               return MEDCouplingCMeshClient::New(meshPtrCppC2);
 227             }
 228           SALOME_MED::MEDCouplingIMeshCorbaInterface_var meshPtrCppC7=SALOME_MED::MEDCouplingIMeshCorbaInterface::_narrow(meshPtrCpp);
 229           if(!CORBA::is_nil(meshPtrCppC7))
 230             {
 231               Py_DECREF(pdict);
 232               Py_DECREF(iorMesh);
 233               return MEDCouplingIMeshClient::New(meshPtrCppC7);
 234             }
 235           SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_var meshPtrCppC3=SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface::_narrow(meshPtrCpp);
 236           if(!CORBA::is_nil(meshPtrCppC3))
 237             {
 238               Py_DECREF(pdict);
 239               Py_DECREF(iorMesh);
 240               return MEDCouplingCurveLinearMeshClient::New(meshPtrCppC3);
 241             }
 242           SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_var meshPtrCppC4=SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface::_narrow(meshPtrCpp);
 243           if(!CORBA::is_nil(meshPtrCppC4))
 244             {
 245               Py_DECREF(pdict);
 246               Py_DECREF(iorMesh);
 247               return MEDCoupling1SGTUMeshClient::New(meshPtrCppC4);
 248             }
 249           SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_var meshPtrCppC5=SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface::_narrow(meshPtrCpp);
 250           if(!CORBA::is_nil(meshPtrCppC5))
 251             {
 252               Py_DECREF(pdict);
 253               Py_DECREF(iorMesh);
 254               return MEDCoupling1DGTUMeshClient::New(meshPtrCppC5);
 255             }
 256           SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_var meshPtrCppC6=SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface::_narrow(meshPtrCpp);
 257           if(!CORBA::is_nil(meshPtrCppC6))
 258             {
 259               Py_DECREF(pdict);
 260               Py_DECREF(iorMesh);
 261               return MEDCouplingExtrudedMeshClient::New(meshPtrCppC6);
 262             }
 263           throw INTERP_KERNEL::Exception("Error input corba pointer is not a managed mesh type !");
 264         }
 265       }
 266   };
 267
 268   class MEDCouplingUMeshClient
 269   {
 270   public:
 271     %extend
 272       {
 273         static MEDCouplingUMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 274         {
 275           PyObject* pdict=PyDict_New();
 276           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 277           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 278           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 279           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 280           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 281           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 282           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 283           if(!iorMesh)
 284             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingUMeshClient.New appears to differ from CORBA reference ! Expecting a UMeshCorbaInterface CORBA reference !");
 285           char *ior=PyString_AsString(iorMesh);
 286           int argc=0;
 287           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 288           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 289           SALOME_MED::MEDCouplingUMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingUMeshCorbaInterface::_narrow(meshPtrCpp);
 290           if(CORBA::is_nil(meshPtrCppC))
 291             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingUMeshInterface_ptr !");
 292           Py_DECREF(pdict);
 293           Py_DECREF(iorMesh);
 294           MEDCouplingUMesh *ret=MEDCouplingUMeshClient::New(meshPtrCppC);
 295           return ret;
 296         }
 297       }
 298   };
 299
 300   class MEDCoupling1SGTUMeshClient
 301   {
 302   public:
 303     %extend
 304       {
 305         static MEDCoupling1SGTUMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 306         {
 307           PyObject* pdict=PyDict_New();
 308           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 309           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 310           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 311           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 312           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 313           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 314           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 315           if(!iorMesh)
 316             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCoupling1SGTUMeshClient.New appears to differ from CORBA reference ! Expecting a 1SGTUMeshCorbaInterface CORBA reference !");
 317           char *ior=PyString_AsString(iorMesh);
 318           int argc=0;
 319           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 320           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 321           SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCoupling1SGTUMeshCorbaInterface::_narrow(meshPtrCpp);
 322           if(CORBA::is_nil(meshPtrCppC))
 323             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCoupling1SGTUMeshInterface_ptr !");
 324           Py_DECREF(pdict);
 325           Py_DECREF(iorMesh);
 326           MEDCoupling1SGTUMesh *ret=MEDCoupling1SGTUMeshClient::New(meshPtrCppC);
 327           return ret;
 328         }
 329       }
 330   };
 331
 332   class MEDCoupling1DGTUMeshClient
 333   {
 334   public:
 335     %extend
 336       {
 337         static MEDCoupling1DGTUMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 338         {
 339           PyObject* pdict=PyDict_New();
 340           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 341           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 342           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 343           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 344           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 345           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 346           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 347           if(!iorMesh)
 348             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCoupling1DGTUMeshClient.New appears to differ from CORBA reference ! Expecting a 1DGTUMeshCorbaInterface CORBA reference !");
 349           char *ior=PyString_AsString(iorMesh);
 350           int argc=0;
 351           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 352           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 353           SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCoupling1DGTUMeshCorbaInterface::_narrow(meshPtrCpp);
 354           if(CORBA::is_nil(meshPtrCppC))
 355             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCoupling1DGTUMeshInterface_ptr !");
 356           Py_DECREF(pdict);
 357           Py_DECREF(iorMesh);
 358           MEDCoupling1DGTUMesh *ret=MEDCoupling1DGTUMeshClient::New(meshPtrCppC);
 359           return ret;
 360         }
 361       }
 362   };
 363
 364   class MEDCouplingExtrudedMeshClient
 365   {
 366   public:
 367     %extend
 368       {
 369         static MEDCouplingExtrudedMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 370         {
 371           PyObject* pdict=PyDict_New();
 372           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 373           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 374           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 375           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 376           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 377           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 378           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 379           if(!iorMesh)
 380             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingExtrudedMeshClient.New appears to differ from CORBA reference ! Expecting an ExtrudedMeshCorbaInterface CORBA reference !");
 381           char *ior=PyString_AsString(iorMesh);
 382           int argc=0;
 383           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 384           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 385           SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface::_narrow(meshPtrCpp);
 386           if(CORBA::is_nil(meshPtrCppC))
 387             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingExtrudedMeshInterface_ptr !");
 388           Py_DECREF(pdict);
 389           Py_DECREF(iorMesh);
 390           MEDCouplingExtrudedMesh *ret=MEDCouplingExtrudedMeshClient::New(meshPtrCppC);
 391           return ret;
 392         }
 393       }
 394   };
 395
 396   class MEDCouplingCMeshClient
 397   {
 398   public:
 399     %extend
 400       {
 401         static MEDCouplingCMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 402         {
 403           PyObject* pdict=PyDict_New();
 404           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 405           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 406           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 407           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 408           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 409           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 410           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 411           if(!iorMesh)
 412             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingCMeshClient.New appears to differ from CORBA reference ! Expecting a CMeshCorbaInterface CORBA reference !");
 413           char *ior=PyString_AsString(iorMesh);
 414           int argc=0;
 415           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 416           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 417           SALOME_MED::MEDCouplingCMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingCMeshCorbaInterface::_narrow(meshPtrCpp);
 418           if(CORBA::is_nil(meshPtrCppC))
 419             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingCMeshInterface_ptr !");
 420           Py_DECREF(pdict);
 421           Py_DECREF(iorMesh);
 422           MEDCouplingCMesh *ret=MEDCouplingCMeshClient::New(meshPtrCppC);
 423           return ret;
 424         }
 425       }
 426   };
 427
 428   class MEDCouplingIMeshClient
 429   {
 430   public:
 431     %extend
 432       {
 433         static MEDCouplingIMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 434         {
 435           PyObject* pdict=PyDict_New();
 436           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 437           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 438           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 439           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 440           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 441           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 442           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 443           if(!iorMesh)
 444             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingIMeshClient.New appears to differ from CORBA reference ! Expecting a IMeshCorbaInterface CORBA reference !");
 445           char *ior=PyString_AsString(iorMesh);
 446           int argc=0;
 447           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 448           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 449           SALOME_MED::MEDCouplingIMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingIMeshCorbaInterface::_narrow(meshPtrCpp);
 450           if(CORBA::is_nil(meshPtrCppC))
 451             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingIMeshInterface_ptr !");
 452           Py_DECREF(pdict);
 453           Py_DECREF(iorMesh);
 454           MEDCouplingIMesh *ret=MEDCouplingIMeshClient::New(meshPtrCppC);
 455           return ret;
 456         }
 457       }
 458   };
 459
 460   class MEDCouplingCurveLinearMeshClient
 461   {
 462   public:
 463     %extend
 464       {
 465         static MEDCouplingCurveLinearMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 466         {
 467           PyObject* pdict=PyDict_New();
 468           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 469           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 470           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 471           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 472           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 473           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 474           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 475           if(!iorMesh)
 476             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingCurveLinearMeshClient.New appears to differ from CORBA reference ! Expecting a CurveLinearMeshCorbaInterface CORBA reference !");
 477           char *ior=PyString_AsString(iorMesh);
 478           int argc=0;
 479           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 480           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 481           SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface::_narrow(meshPtrCpp);
 482           if(CORBA::is_nil(meshPtrCppC))
 483             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingCurveLinearMeshInterface_ptr !");
 484           Py_DECREF(pdict);
 485           Py_DECREF(iorMesh);
 486           MEDCouplingCurveLinearMesh *ret=MEDCouplingCurveLinearMeshClient::New(meshPtrCppC);
 487           return ret;
 488         }
 489       }
 490   };
 491
 492   class DataArrayDoubleClient
 493   {
 494   public:
 495     %extend
 496       {
 497         static DataArrayDouble *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 498         {
 499           PyObject* pdict=PyDict_New();
 500           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 501           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 502           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 503           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 504           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 505           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 506           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 507           if(!iorMesh)
 508             throw INTERP_KERNEL::Exception("Error : the input parameter of DataArrayDoubleClient.New appears to differ from CORBA reference ! Expecting a DataArrayDoubleCorbaInterface CORBA reference !");
 509           char *ior=PyString_AsString(iorMesh);
 510           int argc=0;
 511           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 512           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 513           SALOME_MED::DataArrayDoubleCorbaInterface_var meshPtrCppC=SALOME_MED::DataArrayDoubleCorbaInterface::_narrow(meshPtrCpp);
 514           if(CORBA::is_nil(meshPtrCppC))
 515             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.DataArrayDoubleInterface_ptr ");
 516           Py_DECREF(pdict);
 517           Py_DECREF(iorMesh);
 518           DataArrayDouble *ret=DataArrayDoubleClient::New(meshPtrCppC);
 519           return ret;
 520         }
 521       }
 522   };
 523
 524   class DataArrayIntClient
 525   {
 526   public:
 527     %extend
 528       {
 529         static DataArrayInt *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 530         {
 531           PyObject* pdict=PyDict_New();
 532           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 533           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 534           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 535           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 536           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 537           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 538           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 539           if(!iorMesh)
 540             throw INTERP_KERNEL::Exception("Error : the input parameter of DataArrayIntClient.New appears to differ from CORBA reference ! Expecting a DataArrayIntCorbaInterface CORBA reference !");
 541           char *ior=PyString_AsString(iorMesh);
 542           int argc=0;
 543           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 544           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 545           SALOME_MED::DataArrayIntCorbaInterface_var meshPtrCppC=SALOME_MED::DataArrayIntCorbaInterface::_narrow(meshPtrCpp);
 546           if(CORBA::is_nil(meshPtrCppC))
 547             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.DataArrayIntInterface_ptr !");
 548           Py_DECREF(pdict);
 549           Py_DECREF(iorMesh);
 550           DataArrayInt *ret=DataArrayIntClient::New(meshPtrCppC);
 551           return ret;
 552         }
 553       }
 554   };
 555 }
 556
 557 %pythoncode %{
 558 def ParaMEDMEMDataArrayDoubleIadd(self,*args):
 559     import _MEDCouplingClient
 560     return _MEDCouplingClient.DataArrayDouble____iadd___(self, self, *args)
 561 def ParaMEDMEMDataArrayDoubleIsub(self,*args):
 562     import _MEDCouplingClient
 563     return _MEDCouplingClient.DataArrayDouble____isub___(self, self, *args)
 564 def ParaMEDMEMDataArrayDoubleImul(self,*args):
 565     import _MEDCouplingClient
 566     return _MEDCouplingClient.DataArrayDouble____imul___(self, self, *args)
 567 def ParaMEDMEMDataArrayDoubleIdiv(self,*args):
 568     import _MEDCouplingClient
 569     return _MEDCouplingClient.DataArrayDouble____idiv___(self, self, *args)
 570 def ParaMEDMEMDataArrayDoubleIpow(self,*args):
 571     import _MEDCouplingClient
 572     return _MEDCouplingClient.DataArrayDouble____ipow___(self, self, *args)
 573 def ParaMEDMEMMEDCouplingFieldDoubleIadd(self,*args):
 574     import _MEDCouplingClient
 575     return _MEDCouplingClient.MEDCouplingFieldDouble____iadd___(self, self, *args)
 576 def ParaMEDMEMMEDCouplingFieldDoubleIsub(self,*args):
 577     import _MEDCouplingClient
 578     return _MEDCouplingClient.MEDCouplingFieldDouble____isub___(self, self, *args)
 579 def ParaMEDMEMMEDCouplingFieldDoubleImul(self,*args):
 580     import _MEDCouplingClient
 581     return _MEDCouplingClient.MEDCouplingFieldDouble____imul___(self, self, *args)
 582 def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args):
 583     import _MEDCouplingClient
 584     return _MEDCouplingClient.MEDCouplingFieldDouble____idiv___(self, self, *args)
 585 def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args):
 586     import _MEDCouplingClient
 587     return _MEDCouplingClient.MEDCouplingFieldDouble____ipow___(self, self, *args)
 588 def ParaMEDMEMDataArrayIntIadd(self,*args):
 589     import _MEDCouplingClient
 590     return _MEDCouplingClient.DataArrayInt____iadd___(self, self, *args)
 591 def ParaMEDMEMDataArrayIntIsub(self,*args):
 592     import _MEDCouplingClient
 593     return _MEDCouplingClient.DataArrayInt____isub___(self, self, *args)
 594 def ParaMEDMEMDataArrayIntImul(self,*args):
 595     import _MEDCouplingClient
 596     return _MEDCouplingClient.DataArrayInt____imul___(self, self, *args)
 597 def ParaMEDMEMDataArrayIntIdiv(self,*args):
 598     import _MEDCouplingClient
 599     return _MEDCouplingClient.DataArrayInt____idiv___(self, self, *args)
 600 def ParaMEDMEMDataArrayIntImod(self,*args):
 601     import _MEDCouplingClient
 602     return _MEDCouplingClient.DataArrayInt____imod___(self, self, *args)
 603 def ParaMEDMEMDataArrayIntIpow(self,*args):
 604     import _MEDCouplingClient
 605     return _MEDCouplingClient.DataArrayInt____ipow___(self, self, *args)
 606 def ParaMEDMEMDataArrayDoubleTupleIadd(self,*args):
 607     import _MEDCouplingClient
 608     return _MEDCouplingClient.DataArrayDoubleTuple____iadd___(self, self, *args)
 609 def ParaMEDMEMDataArrayDoubleTupleIsub(self,*args):
 610     import _MEDCouplingClient
 611     return _MEDCouplingClient.DataArrayDoubleTuple____isub___(self, self, *args)
 612 def ParaMEDMEMDataArrayDoubleTupleImul(self,*args):
 613     import _MEDCouplingClient
 614     return _MEDCouplingClient.DataArrayDoubleTuple____imul___(self, self, *args)
 615 def ParaMEDMEMDataArrayDoubleTupleIdiv(self,*args):
 616     import _MEDCouplingClient
 617     return _MEDCouplingClient.DataArrayDoubleTuple____idiv___(self, self, *args)
 618 def ParaMEDMEMDataArrayIntTupleIadd(self,*args):
 619     import _MEDCouplingClient
 620     return _MEDCouplingClient.DataArrayIntTuple____iadd___(self, self, *args)
 621 def ParaMEDMEMDataArrayIntTupleIsub(self,*args):
 622     import _MEDCouplingClient
 623     return _MEDCouplingClient.DataArrayIntTuple____isub___(self, self, *args)
 624 def ParaMEDMEMDataArrayIntTupleImul(self,*args):
 625     import _MEDCouplingClient
 626     return _MEDCouplingClient.DataArrayIntTuple____imul___(self, self, *args)
 627 def ParaMEDMEMDataArrayIntTupleIdiv(self,*args):
 628     import _MEDCouplingClient
 629     return _MEDCouplingClient.DataArrayIntTuple____idiv___(self, self, *args)
 630 def ParaMEDMEMDataArrayIntTupleImod(self,*args):
 631     import _MEDCouplingClient
 632     return _MEDCouplingClient.DataArrayIntTuple____imod___(self, self, *args)
 633 %}
 634
 635 %include "MEDCouplingFinalize.i"