From: Anthony Geay Date: Tue, 3 Mar 2015 18:08:07 +0000 (+0100) Subject: A big problem for int32. Need investigation. X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=5406a0c6473f0f7ef70461d1be83668fc48a960b;p=tools%2Fmedcoupling.git A big problem for int32. Need investigation. --- diff --git a/src/MEDCoupling_Swig/CMakeLists.txt b/src/MEDCoupling_Swig/CMakeLists.txt index 28c1d951a..108897c53 100644 --- a/src/MEDCoupling_Swig/CMakeLists.txt +++ b/src/MEDCoupling_Swig/CMakeLists.txt @@ -90,4 +90,6 @@ SET_TESTS_PROPERTIES(MEDCouplingRemapperTest PROPERTIES ENVIRONMENT "${tests_env IF(NUMPY_FOUND) ADD_TEST(MEDCouplingNumPyTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingNumPyTest.py) SET_TESTS_PROPERTIES(MEDCouplingNumPyTest PROPERTIES ENVIRONMENT "${tests_env}") + ADD_TEST(MEDCouplingPickleTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingPickleTest.py) + SET_TESTS_PROPERTIES(MEDCouplingPickleTest PROPERTIES ENVIRONMENT "${tests_env}") ENDIF(NUMPY_FOUND) diff --git a/src/MEDCoupling_Swig/MEDCoupling.i b/src/MEDCoupling_Swig/MEDCoupling.i index 2091a046e..02eb0c768 100644 --- a/src/MEDCoupling_Swig/MEDCoupling.i +++ b/src/MEDCoupling_Swig/MEDCoupling.i @@ -53,6 +53,9 @@ def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args): def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args): import _MEDCoupling return _MEDCoupling.MEDCouplingFieldDouble____ipow___(self, self, *args) +def ParaMEDMEMDataArrayIntnew(cls,*args): + import _MEDCoupling + return _MEDCoupling.DataArrayInt____new___(cls,args) def ParaMEDMEMDataArrayIntIadd(self,*args): import _MEDCoupling return _MEDCoupling.DataArrayInt____iadd___(self, self, *args) diff --git a/src/MEDCoupling_Swig/MEDCouplingFinalize.i b/src/MEDCoupling_Swig/MEDCouplingFinalize.i index 7d6bafb8b..12502f150 100644 --- a/src/MEDCoupling_Swig/MEDCouplingFinalize.i +++ b/src/MEDCoupling_Swig/MEDCouplingFinalize.i @@ -25,6 +25,7 @@ DataArrayDouble.__imul__=ParaMEDMEMDataArrayDoubleImul DataArrayDouble.__idiv__=ParaMEDMEMDataArrayDoubleIdiv DataArrayDouble.__ipow__=ParaMEDMEMDataArrayDoubleIpow +DataArrayInt.__new__=classmethod(ParaMEDMEMDataArrayIntnew) DataArrayInt.__iadd__=ParaMEDMEMDataArrayIntIadd DataArrayInt.__isub__=ParaMEDMEMDataArrayIntIsub DataArrayInt.__imul__=ParaMEDMEMDataArrayIntImul @@ -62,6 +63,7 @@ del ParaMEDMEMMEDCouplingFieldDoubleIsub del ParaMEDMEMMEDCouplingFieldDoubleImul del ParaMEDMEMMEDCouplingFieldDoubleIdiv del ParaMEDMEMMEDCouplingFieldDoubleIpow +del ParaMEDMEMDataArrayIntnew del ParaMEDMEMDataArrayIntIadd del ParaMEDMEMDataArrayIntIsub del ParaMEDMEMDataArrayIntImul diff --git a/src/MEDCoupling_Swig/MEDCouplingMemArray.i b/src/MEDCoupling_Swig/MEDCouplingMemArray.i index 561ecb820..ef5df069e 100644 --- a/src/MEDCoupling_Swig/MEDCouplingMemArray.i +++ b/src/MEDCoupling_Swig/MEDCouplingMemArray.i @@ -476,6 +476,41 @@ namespace ParaMEDMEM GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !"); return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,""); } + + PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) + { + PyObject *ret(PyTuple_New(2)); + std::string a0(self->getName()); + const std::vector &a1(self->getInfoOnComponents()); + PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str())); + // + int sz(a1.size()); + PyObject *ret1(PyList_New(sz)); + for(int i=0;i a1cpp; + if(!fillStringVector(a1,a1cpp)) + throw INTERP_KERNEL::Exception(MSG); + self->setName(PyString_AsString(a0)); + self->setInfoOnComponents(a1cpp); + } } }; @@ -2231,41 +2266,6 @@ namespace ParaMEDMEM throw INTERP_KERNEL::Exception("PyWrap of DataArrayDouble.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); #endif } - - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) - { - PyObject *ret(PyTuple_New(2)); - std::string a0(self->getName()); - const std::vector &a1(self->getInfoOnComponents()); - PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str())); - // - int sz(a1.size()); - PyObject *ret1(PyList_New(sz)); - for(int i=0;i a1cpp; - if(!fillStringVector(a1,a1cpp)) - throw INTERP_KERNEL::Exception(MSG); - self->setName(PyString_AsString(a0)); - self->setInfoOnComponents(a1cpp); - } } }; @@ -4570,6 +4570,66 @@ namespace ParaMEDMEM PyTuple_SetItem(pyRet,1,ret1Py); return pyRet; } + + // serialization + static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) + { + static const char MSG[]="DataArrayInt.__new__ : the args in input is expected to be a tuple of size 2 !"; + if(!PyTuple_Check(args)) + throw INTERP_KERNEL::Exception(MSG); + PyObject *builtinsd(PyEval_GetBuiltins());//borrowed + PyObject *obj(PyDict_GetItemString(builtinsd,"object"));//borrowed + PyObject *selfMeth(PyObject_GetAttrString(obj,"__new__")); + // + PyObject *tmp0(PyTuple_New(1)); + PyTuple_SetItem(tmp0,0,cls); Py_XINCREF(cls); + PyObject *instance(PyObject_CallObject(selfMeth,tmp0)); + Py_DECREF(tmp0); + Py_DECREF(selfMeth); + PyObject *initMeth(PyObject_GetAttrString(instance,"__init__")); + int sz(PyTuple_Size(args)); + + if(PyTuple_Size(args)==2 && PyDict_Check(PyTuple_GetItem(args,1)) && PyDict_Size(PyTuple_GetItem(args,1))==1 ) + {// NOT general case. only true if in unpickeling context ! call __init__. Because for all other cases, __init__ is called right after __new__ ! + PyObject *zeNumpyRepr(0); + { + PyObject *tmp1(PyInt_FromLong(0)); + zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed + Py_DECREF(tmp1); + } + { + PyObject *tmp3(PyTuple_New(1)); + PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr); + // agy : WHY ! I don't know but valgrind complains strongly if not done ! + // Question is why double does not need it ? It leads to mem leak ! + //Py_XINCREF(zeNumpyRepr); + PyObject *tmp2(PyObject_CallObject(initMeth,tmp3)); + Py_XDECREF(tmp2); + Py_DECREF(tmp3); + } + } + Py_DECREF(initMeth); + return instance; + } + + PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) + { +#ifdef WITH_NUMPY + if(!self->isAllocated()) + throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : self is not allocated !"); + PyObject *ret(PyTuple_New(1)); + PyObject *ret0(PyDict_New()); + PyObject *numpyArryObj(ParaMEDMEM_DataArrayInt_toNumPyArray(self)); + {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ... + PyObject *tmp1(PyInt_FromLong(0)); + PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj); + PyTuple_SetItem(ret,0,ret0); + } + return ret; +#else + throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !"); +#endif + } } }; diff --git a/src/MEDCoupling_Swig/MEDCouplingRemapper.i b/src/MEDCoupling_Swig/MEDCouplingRemapper.i index bb07661b7..b1c082cab 100644 --- a/src/MEDCoupling_Swig/MEDCouplingRemapper.i +++ b/src/MEDCoupling_Swig/MEDCouplingRemapper.i @@ -136,6 +136,9 @@ def ParaMEDMEMMEDCouplingFieldDoubleIdiv(self,*args): def ParaMEDMEMMEDCouplingFieldDoubleIpow(self,*args): import _MEDCouplingRemapper return _MEDCouplingRemapper.MEDCouplingFieldDouble____ipow___(self, self, *args) +def ParaMEDMEMDataArrayIntnew(cls,*args): + import _MEDCoupling + return _MEDCoupling.DataArrayInt____new___(cls,args) def ParaMEDMEMDataArrayIntIadd(self,*args): import _MEDCouplingRemapper return _MEDCouplingRemapper.DataArrayInt____iadd___(self, self, *args)