src/MEDCouplingCorba_Swig/Client/MEDCouplingClient.i

   1 // Copyright (C) 2007-2013  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.
   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 "MEDCouplingExtrudedMeshClient.hxx"
  30 #include "MEDCouplingCMeshClient.hxx"
  31 #include "MEDCouplingCurveLinearMeshClient.hxx"
  32 #include "DataArrayDoubleClient.hxx"
  33 #include "DataArrayIntClient.hxx"
  34
  35 #include <iostream>
  36
  37 using namespace ParaMEDMEM;
  38 %}
  39
  40 %include "MEDCouplingCommon.i"
  41
  42 %newobject ParaMEDMEM::MEDCouplingFieldDoubleClient::New;
  43 %newobject ParaMEDMEM::MEDCouplingFieldTemplateClient::New;
  44 %newobject ParaMEDMEM::MEDCouplingUMeshClient::New;
  45 %newobject ParaMEDMEM::MEDCouplingExtrudedMeshClient::New;
  46 %newobject ParaMEDMEM::MEDCouplingCMeshClient::New;
  47 %newobject ParaMEDMEM::MEDCouplingCurveLinearMeshClient::New;
  48 %newobject ParaMEDMEM::MEDCouplingMultiFieldsClient::New;
  49 %newobject ParaMEDMEM::MEDCouplingFieldOverTimeClient::New;
  50 %newobject ParaMEDMEM::DataArrayDoubleClient::New;
  51 %newobject ParaMEDMEM::DataArrayIntClient::New;
  52
  53 %nodefaultctor;
  54 %nodefaultdtor;
  55
  56 namespace ParaMEDMEM
  57 {
  58   class MEDCouplingFieldDoubleClient
  59   {
  60   public:
  61     %extend
  62       {
  63         static MEDCouplingFieldDouble *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
  64         {
  65           PyObject* pdict=PyDict_New();
  66           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
  67           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
  68           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
  69           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
  70           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
  71           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
  72           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
  73           if(!iorField)
  74             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldDoubleClient.New appears to differ from CORBA reference ! Expecting a FieldDouble CORBA reference !");
  75           char *ior=PyString_AsString(iorField);
  76           int argc=0;
  77           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
  78           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
  79           SALOME_MED::MEDCouplingFieldDoubleCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldDoubleCorbaInterface::_narrow(fieldPtrCpp);
  80           if(CORBA::is_nil(fieldPtrCppC))
  81             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldDoubleCorbaInterface_ptr !");
  82           Py_DECREF(pdict);
  83           Py_DECREF(iorField);
  84           MEDCouplingFieldDouble *ret=MEDCouplingFieldDoubleClient::New(fieldPtrCppC);
  85           return ret;
  86         }
  87       }
  88   };
  89
  90   class MEDCouplingFieldTemplateClient
  91   {
  92   public:
  93     %extend
  94       {
  95         static MEDCouplingFieldTemplate *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
  96         {
  97           PyObject* pdict=PyDict_New();
  98           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
  99           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 100           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 101           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 102           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 103           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 104           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 105           if(!iorField)
 106             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldTemplateClient.New appears to differ from CORBA reference ! Expecting a FieldTemplate CORBA reference !");
 107           char *ior=PyString_AsString(iorField);
 108           int argc=0;
 109           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 110           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 111           SALOME_MED::MEDCouplingFieldTemplateCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldTemplateCorbaInterface::_narrow(fieldPtrCpp);
 112           if(CORBA::is_nil(fieldPtrCppC))
 113             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldTemplateCorbaInterface_ptr !");
 114           Py_DECREF(pdict);
 115           Py_DECREF(iorField);
 116           MEDCouplingFieldTemplate *ret=MEDCouplingFieldTemplateClient::New(fieldPtrCppC);
 117           return ret;
 118         }
 119       }
 120   };
 121
 122   class MEDCouplingMultiFieldsClient
 123   {
 124   public:
 125     %extend
 126       {
 127         static MEDCouplingMultiFields *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
 128         {
 129           PyObject* pdict=PyDict_New();
 130           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 131           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 132           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 133           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 134           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 135           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 136           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 137           if(!iorField)
 138             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldTemplateClient.New appears to differ from CORBA reference ! Expecting a MultiFields CORBA reference !");
 139           char *ior=PyString_AsString(iorField);
 140           int argc=0;
 141           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 142           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 143           SALOME_MED::MEDCouplingMultiFieldsCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingMultiFieldsCorbaInterface::_narrow(fieldPtrCpp);
 144           if(CORBA::is_nil(fieldPtrCppC))
 145             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingMultiFieldsCorbaInterface_ptr !");
 146           Py_DECREF(pdict);
 147           Py_DECREF(iorField);
 148           MEDCouplingMultiFields *ret=MEDCouplingMultiFieldsClient::New(fieldPtrCppC);
 149           return ret;
 150         }
 151       }
 152   };
 153
 154   class MEDCouplingFieldOverTimeClient : public MEDCouplingFieldOverTime
 155   {
 156   public:
 157     std::vector<double> getTimeSteps() const;
 158     %extend
 159       {
 160         static MEDCouplingFieldOverTimeClient *New(PyObject *fieldPtr) throw(INTERP_KERNEL::Exception)
 161         {
 162           PyObject* pdict=PyDict_New();
 163           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 164           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 165           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 166           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 167           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 168           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 169           PyObject *iorField=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",fieldPtr);
 170           if(!iorField)
 171             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingFieldOverTimeClient.New appears to differ from CORBA reference ! Expecting a FieldOverTime CORBA reference !");
 172           char *ior=PyString_AsString(iorField);
 173           int argc=0;
 174           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 175           CORBA::Object_var fieldPtrCpp=orb->string_to_object(ior);
 176           SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface_var fieldPtrCppC=SALOME_MED::MEDCouplingFieldOverTimeCorbaInterface::_narrow(fieldPtrCpp);
 177           if(CORBA::is_nil(fieldPtrCppC))
 178             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingFieldOverTimeCorbaInterface_ptr !");
 179           Py_DECREF(pdict);
 180           Py_DECREF(iorField);
 181           MEDCouplingFieldOverTimeClient *ret=MEDCouplingFieldOverTimeClient::New(fieldPtrCppC);
 182           return ret;
 183         }
 184       }
 185   };
 186
 187   class MEDCouplingUMeshClient
 188   {
 189   public:
 190     %extend
 191       {
 192         static MEDCouplingUMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 193         {
 194           PyObject* pdict=PyDict_New();
 195           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 196           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 197           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 198           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 199           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 200           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 201           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 202           if(!iorMesh)
 203             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingUMeshClient.New appears to differ from CORBA reference ! Expecting a UMeshCorbaInterface CORBA reference !");
 204           char *ior=PyString_AsString(iorMesh);
 205           int argc=0;
 206           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 207           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 208           SALOME_MED::MEDCouplingUMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingUMeshCorbaInterface::_narrow(meshPtrCpp);
 209           if(CORBA::is_nil(meshPtrCppC))
 210             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingUMeshInterface_ptr !");
 211           Py_DECREF(pdict);
 212           Py_DECREF(iorMesh);
 213           MEDCouplingUMesh *ret=MEDCouplingUMeshClient::New(meshPtrCppC);
 214           return ret;
 215         }
 216       }
 217   };
 218
 219   class MEDCouplingExtrudedMeshClient
 220   {
 221   public:
 222     %extend
 223       {
 224         static MEDCouplingExtrudedMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 225         {
 226           PyObject* pdict=PyDict_New();
 227           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 228           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 229           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 230           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 231           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 232           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 233           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 234           if(!iorMesh)
 235             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingExtrudedMeshClient.New appears to differ from CORBA reference ! Expecting an ExtrudedMeshCorbaInterface CORBA reference !");
 236           char *ior=PyString_AsString(iorMesh);
 237           int argc=0;
 238           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 239           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 240           SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingExtrudedMeshCorbaInterface::_narrow(meshPtrCpp);
 241           if(CORBA::is_nil(meshPtrCppC))
 242             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingExtrudedMeshInterface_ptr !");
 243           Py_DECREF(pdict);
 244           Py_DECREF(iorMesh);
 245           MEDCouplingExtrudedMesh *ret=MEDCouplingExtrudedMeshClient::New(meshPtrCppC);
 246           return ret;
 247         }
 248       }
 249   };
 250
 251   class MEDCouplingCMeshClient
 252   {
 253   public:
 254     %extend
 255       {
 256         static MEDCouplingCMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 257         {
 258           PyObject* pdict=PyDict_New();
 259           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 260           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 261           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 262           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 263           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 264           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 265           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 266           if(!iorMesh)
 267             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingCMeshClient.New appears to differ from CORBA reference ! Expecting a CMeshCorbaInterface CORBA reference !");
 268           char *ior=PyString_AsString(iorMesh);
 269           int argc=0;
 270           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 271           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 272           SALOME_MED::MEDCouplingCMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingCMeshCorbaInterface::_narrow(meshPtrCpp);
 273           if(CORBA::is_nil(meshPtrCppC))
 274             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingCMeshInterface_ptr !");
 275           Py_DECREF(pdict);
 276           Py_DECREF(iorMesh);
 277           MEDCouplingCMesh *ret=MEDCouplingCMeshClient::New(meshPtrCppC);
 278           return ret;
 279         }
 280       }
 281   };
 282
 283   class MEDCouplingCurveLinearMeshClient
 284   {
 285   public:
 286     %extend
 287       {
 288         static MEDCouplingCurveLinearMesh *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 289         {
 290           PyObject* pdict=PyDict_New();
 291           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 292           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 293           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 294           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 295           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 296           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 297           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 298           if(!iorMesh)
 299             throw INTERP_KERNEL::Exception("Error : the input parameter of MEDCouplingCurveLinearMeshClient.New appears to differ from CORBA reference ! Expecting a CurveLinearMeshCorbaInterface CORBA reference !");
 300           char *ior=PyString_AsString(iorMesh);
 301           int argc=0;
 302           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 303           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 304           SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface_var meshPtrCppC=SALOME_MED::MEDCouplingCurveLinearMeshCorbaInterface::_narrow(meshPtrCpp);
 305           if(CORBA::is_nil(meshPtrCppC))
 306             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.MEDCouplingCurveLinearMeshInterface_ptr !");
 307           Py_DECREF(pdict);
 308           Py_DECREF(iorMesh);
 309           MEDCouplingCurveLinearMesh *ret=MEDCouplingCurveLinearMeshClient::New(meshPtrCppC);
 310           return ret;
 311         }
 312       }
 313   };
 314
 315   class DataArrayDoubleClient
 316   {
 317   public:
 318     %extend
 319       {
 320         static DataArrayDouble *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 321         {
 322           PyObject* pdict=PyDict_New();
 323           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 324           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 325           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 326           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 327           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 328           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 329           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 330           if(!iorMesh)
 331             throw INTERP_KERNEL::Exception("Error : the input parameter of DataArrayDoubleClient.New appears to differ from CORBA reference ! Expecting a DataArrayDoubleCorbaInterface CORBA reference !");
 332           char *ior=PyString_AsString(iorMesh);
 333           int argc=0;
 334           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 335           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 336           SALOME_MED::DataArrayDoubleCorbaInterface_var meshPtrCppC=SALOME_MED::DataArrayDoubleCorbaInterface::_narrow(meshPtrCpp);
 337           if(CORBA::is_nil(meshPtrCppC))
 338             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.DataArrayDoubleInterface_ptr ");
 339           Py_DECREF(pdict);
 340           Py_DECREF(iorMesh);
 341           DataArrayDouble *ret=DataArrayDoubleClient::New(meshPtrCppC);
 342           return ret;
 343         }
 344       }
 345   };
 346
 347   class DataArrayIntClient
 348   {
 349   public:
 350     %extend
 351       {
 352         static DataArrayInt *New(PyObject *meshPtr) throw(INTERP_KERNEL::Exception)
 353         {
 354           PyObject* pdict=PyDict_New();
 355           PyDict_SetItemString(pdict,"__builtins__",PyEval_GetBuiltins());
 356           PyRun_String("import MEDCouplingCorbaServant_idl",Py_single_input,pdict, pdict);
 357           PyRun_String("import CORBA",Py_single_input,pdict, pdict);
 358           PyRun_String("orbTmp15634=CORBA.ORB_init([''])", Py_single_input,pdict, pdict);
 359           PyObject *orbPython=PyDict_GetItemString(pdict,"orbTmp15634");
 360           // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 361           PyObject *iorMesh=PyObject_CallMethod(orbPython,(char*)"object_to_string",(char*)"O",meshPtr);
 362           if(!iorMesh)
 363             throw INTERP_KERNEL::Exception("Error : the input parameter of DataArrayIntClient.New appears to differ from CORBA reference ! Expecting a DataArrayIntCorbaInterface CORBA reference !");
 364           char *ior=PyString_AsString(iorMesh);
 365           int argc=0;
 366           CORBA::ORB_var orb=CORBA::ORB_init(argc,0);
 367           CORBA::Object_var meshPtrCpp=orb->string_to_object(ior);
 368           SALOME_MED::DataArrayIntCorbaInterface_var meshPtrCppC=SALOME_MED::DataArrayIntCorbaInterface::_narrow(meshPtrCpp);
 369           if(CORBA::is_nil(meshPtrCppC))
 370             throw INTERP_KERNEL::Exception("error corba pointer is not a SALOME_MED.DataArrayIntInterface_ptr !");
 371           Py_DECREF(pdict);
 372           Py_DECREF(iorMesh);
 373           DataArrayInt *ret=DataArrayIntClient::New(meshPtrCppC);
 374           return ret;
 375         }
 376       }
 377   };
 378 }
 379
 380 %pythoncode %{
 381 def ParaMEDMEMDataArrayDoubleIadd(self,*args):
 382     import _MEDCouplingClient
 383     return _MEDCouplingClient.DataArrayDouble____iadd___(self, self, *args)
 384 def ParaMEDMEMDataArrayDoubleIsub(self,*args):
 385     import _MEDCouplingClient
 386     return _MEDCouplingClient.DataArrayDouble____isub___(self, self, *args)
 387 def ParaMEDMEMDataArrayDoubleImul(self,*args):
 388     import _MEDCouplingClient
 389     return _MEDCouplingClient.DataArrayDouble____imul___(self, self, *args)
 390 def ParaMEDMEMDataArrayDoubleIdiv(self,*args):
 391     import _MEDCouplingClient
 392     return _MEDCouplingClient.DataArrayDouble____idiv___(self, self, *args)
 393 def ParaMEDMEMDataArrayDoubleIpow(self,*args):
 394     import _MEDCouplingClient
 395     return _MEDCouplingClient.DataArrayDouble____ipow___(self, self, *args)
 396 def ParaMEDMEMMEDCouplingFieldDoubleIadd(self,*args):
 397     import _MEDCouplingClient
 398     return _MEDCouplingClient.MEDCouplingFieldDouble____iadd___(self, self, *args)
 399 def ParaMEDMEMMEDCouplingFieldDoubleIsub(self,*args):
 400     import _MEDCouplingClient
 401     return _MEDCouplingClient.MEDCouplingFieldDouble____isub___(self, self, *args)
 402 def ParaMEDMEMMEDCouplingFieldDoubleImul(self,*args):
 403     import _MEDCouplingClient
 404     return _MEDCouplingClient.MEDCouplingFieldDouble____imul___(self, self, *args)
 405 def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args):
 406     import _MEDCouplingClient
 407     return _MEDCouplingClient.MEDCouplingFieldDouble____idiv___(self, self, *args)
 408 def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args):
 409     import _MEDCouplingClient
 410     return _MEDCouplingClient.MEDCouplingFieldDouble____ipow___(self, self, *args)
 411 def ParaMEDMEMDataArrayIntIadd(self,*args):
 412     import _MEDCouplingClient
 413     return _MEDCouplingClient.DataArrayInt____iadd___(self, self, *args)
 414 def ParaMEDMEMDataArrayIntIsub(self,*args):
 415     import _MEDCouplingClient
 416     return _MEDCouplingClient.DataArrayInt____isub___(self, self, *args)
 417 def ParaMEDMEMDataArrayIntImul(self,*args):
 418     import _MEDCouplingClient
 419     return _MEDCouplingClient.DataArrayInt____imul___(self, self, *args)
 420 def ParaMEDMEMDataArrayIntIdiv(self,*args):
 421     import _MEDCouplingClient
 422     return _MEDCouplingClient.DataArrayInt____idiv___(self, self, *args)
 423 def ParaMEDMEMDataArrayIntImod(self,*args):
 424     import _MEDCouplingClient
 425     return _MEDCouplingClient.DataArrayInt____imod___(self, self, *args)
 426 def ParaMEDMEMDataArrayIntIpow(self,*args):
 427     import _MEDCouplingClient
 428     return _MEDCouplingClient.DataArrayInt____ipow___(self, self, *args)
 429 def ParaMEDMEMDataArrayDoubleTupleIadd(self,*args):
 430     import _MEDCouplingClient
 431     return _MEDCouplingClient.DataArrayDoubleTuple____iadd___(self, self, *args)
 432 def ParaMEDMEMDataArrayDoubleTupleIsub(self,*args):
 433     import _MEDCouplingClient
 434     return _MEDCouplingClient.DataArrayDoubleTuple____isub___(self, self, *args)
 435 def ParaMEDMEMDataArrayDoubleTupleImul(self,*args):
 436     import _MEDCouplingClient
 437     return _MEDCouplingClient.DataArrayDoubleTuple____imul___(self, self, *args)
 438 def ParaMEDMEMDataArrayDoubleTupleIdiv(self,*args):
 439     import _MEDCouplingClient
 440     return _MEDCouplingClient.DataArrayDoubleTuple____idiv___(self, self, *args)
 441 def ParaMEDMEMDataArrayIntTupleIadd(self,*args):
 442     import _MEDCouplingClient
 443     return _MEDCouplingClient.DataArrayIntTuple____iadd___(self, self, *args)
 444 def ParaMEDMEMDataArrayIntTupleIsub(self,*args):
 445     import _MEDCouplingClient
 446     return _MEDCouplingClient.DataArrayIntTuple____isub___(self, self, *args)
 447 def ParaMEDMEMDataArrayIntTupleImul(self,*args):
 448     import _MEDCouplingClient
 449     return _MEDCouplingClient.DataArrayIntTuple____imul___(self, self, *args)
 450 def ParaMEDMEMDataArrayIntTupleIdiv(self,*args):
 451     import _MEDCouplingClient
 452     return _MEDCouplingClient.DataArrayIntTuple____idiv___(self, self, *args)
 453 def ParaMEDMEMDataArrayIntTupleImod(self,*args):
 454     import _MEDCouplingClient
 455     return _MEDCouplingClient.DataArrayIntTuple____imod___(self, self, *args)
 456 %}
 457
 458 %include "MEDCouplingFinalize.i"