]> SALOME platform Git repositories - tools/medcoupling.git/commitdiff
Salome HOME
[EDF23724] : Get rid of DataArrayMedInt class not castable into DataArrayInt32 nor...
authorAnthony Geay <anthony.geay@edf.fr>
Wed, 16 Jun 2021 11:59:08 +0000 (13:59 +0200)
committerAnthony Geay <anthony.geay@edf.fr>
Wed, 16 Jun 2021 13:15:35 +0000 (15:15 +0200)
src/CMakeLists.txt
src/MEDLoader/MEDFileBasis.hxx
src/MEDLoader/MEDFileEquivalence.cxx
src/MEDLoader/MEDFileFieldGlobs.cxx
src/MEDLoader/MEDFileFieldMultiTS.cxx
src/MEDLoader/MEDFileMeshElt.cxx
src/MEDLoader/MEDLoader.cxx
src/MEDLoader/Swig/MEDLoaderTest4.py

index cbdccb0a8fc5101db3a83f275343b9926dfcb187..1bce32afd1ec92153ebfd4f764c006402605c77b 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+if(MED_INT_IS_LONG)
+  add_definitions(-DMED_INT_IS_LONG)
+endif(MED_INT_IS_LONG)
+
 # InterpKERNEL
 ADD_SUBDIRECTORY(INTERP_KERNEL)
 IF(MEDCOUPLING_BUILD_TESTS)
index 32888e774adc3c88d62228c83788bbf27b2938a7..7fc94555e11de59c35530903dabb06a161fb2ab7 100644 (file)
@@ -66,30 +66,21 @@ namespace MEDCoupling
 
 namespace MEDCoupling
 {
+#ifdef MED_INT_IS_LONG
+  using DataArrayMedInt = DataArrayInt64;
+#else
+  using DataArrayMedInt = DataArrayInt32;
+#endif
 
-  class DataArrayMedInt : public DataArrayDiscreteSigned< med_int >
+  template<class INTARRAY>
+  DataArrayMedInt * DataArrayMedInt_Copy( const INTARRAY* intArray )
   {
-    friend class DataArrayDiscrete<med_int>;
-  public:
-    template<class INTARRAY>
-    static DataArrayMedInt *Copy( const INTARRAY* array );
-    static DataArrayMedInt *New() { return new DataArrayMedInt(); }
-    std::string getClassName() const override { return std::string("DataArrayMedInt"); }
-    DataArrayMedInt *deepCopy() const { return new DataArrayMedInt(*this); }
-    //DataArrayMedInt *buildNewEmptyInstance() const { return new DataArrayMedInt(); }//ko
-    DataArray *buildNewEmptyInstance() const { if ( sizeof(med_int)==sizeof(int)) return DataArrayInt32::New(); return DataArrayInt64::New(); }
-  public:
-    DataArrayMedInt *copySorted(bool asc=true) const override { MCAuto<DataArrayMedInt> ret(this->deepCopy()); ret->sort(); return ret.retn(); }
-    DataArray *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
-    DataArray *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
-    DataArray *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
-    DataArray *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return this->myKeepSelectedComponents(compoIds); }
-    DataArray *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return this->mySelectByTupleIdSafeSlice(bg,end2,step); }
-    DataArray *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return this->mySelectByTupleRanges(ranges); }
-  private:
-    ~DataArrayMedInt() { }
-    DataArrayMedInt() { }
-  };
+    DataArrayMedInt* medIntArray = DataArrayMedInt::New();
+    medIntArray->alloc( intArray->getNumberOfTuples(), intArray->getNumberOfComponents() );
+    medIntArray->copyStringInfoFrom( *intArray );
+    std::copy( intArray->begin(), intArray->end(), medIntArray->getPointer() );
+    return medIntArray;
+  }
 
   template< class T1, class T2 >
   MCAuto<T1> StaticCast( const MCAuto< T2 >& array )
@@ -106,7 +97,7 @@ namespace MEDCoupling
   {
     if ( sizeof( med_int ) == sizeof( typename INTARRAY::Type ))
       return StaticCast< DataArrayMedInt >( intArray );
-    return DataArrayMedInt::Copy((const INTARRAY*) intArray );
+    return DataArrayMedInt_Copy((const INTARRAY*) intArray );
   }
 
   template< class INT >
@@ -119,7 +110,7 @@ namespace MEDCoupling
       ia->incrRef();
       return StaticCast< DataArrayMedInt >( ia );
     }
-    return DataArrayMedInt::Copy( intArray );
+    return DataArrayMedInt_Copy( intArray );
   }
 
   template< class INT >
@@ -164,15 +155,6 @@ namespace MEDCoupling
     return static_cast< INT >( mi );
   }
 
-  template<class INTARRAY>
-  DataArrayMedInt * DataArrayMedInt::Copy( const INTARRAY* intArray )
-  {
-    DataArrayMedInt* medIntArray = DataArrayMedInt::New();
-    medIntArray->alloc( intArray->getNumberOfTuples(), intArray->getNumberOfComponents() );
-    medIntArray->copyStringInfoFrom( *intArray );
-    std::copy( intArray->begin(), intArray->end(), medIntArray->getPointer() );
-    return medIntArray;
-  }
 }
 
 #endif
index 034d895822589142c2b49a7c60db02403b675e05..58640f6d1288415e62572e1874926fe5e60ade49 100644 (file)
@@ -512,7 +512,7 @@ void MEDFileEquivalenceData::writeAdvanced(med_idt fid, med_entity_type medtype,
   INTERP_KERNEL::AutoPtr<char> name(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
   MEDLoaderBase::safeStrCpy(meshName.c_str(),MED_NAME_SIZE,meshName2,getFather()->getMesh()->getTooLongStrPolicy());
   MEDLoaderBase::safeStrCpy(equName.c_str(),MED_NAME_SIZE,name,getFather()->getMesh()->getTooLongStrPolicy());
-  MCAuto<DataArrayMedInt> da2(DataArrayMedInt::Copy(da)); da2->rearrange(1); da2->applyLin(1,1); da2->rearrange(2);
+  MCAuto<DataArrayMedInt> da2(DataArrayMedInt_Copy(da)); da2->rearrange(1); da2->applyLin(1,1); da2->rearrange(2);
   MEDFILESAFECALLERWR0(MEDequivalenceCorrespondenceWr,(fid,meshName2,name,dt,it,medtype,medgt,ToMedInt(da2->getNumberOfTuples()),da2->begin()));
 }
 
index 52dcafb5cdc1645c65e45ee51324d216fe9181db..3dfcebd2f0705e9bee90a3d814a97d8b719e05a1 100644 (file)
@@ -74,7 +74,7 @@ void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) co
   std::size_t nbOfPfls=_pfls.size();
   for(std::size_t i=0;i<nbOfPfls;i++)
     {
-      MCAuto<DataArrayMedInt> cpy=DataArrayMedInt::Copy((const DataArrayIdType*)_pfls[i]);
+      MCAuto<DataArrayMedInt> cpy=DataArrayMedInt_Copy((const DataArrayIdType*)_pfls[i]);
       cpy->applyLin(1,1,0);
       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
index 62a98ce78db2c2f51c865b93f8718fc536cff3bb..8376767e727948d258aba24f511bcd013691acbb 100644 (file)
@@ -496,18 +496,18 @@ void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysR
   MEDFileCapability mfcap(fid);
   if( ( !entities || entities->areAllStaticPresentAndNoDyn() ) && mfcap.isFastReader())
     {// no entities
-      int nentitype(MEDfieldnEntityType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT));
+      med_int nentitype(MEDfieldnEntityType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT));
       INTERP_KERNEL::AutoPtr<med_entity_type> types(new med_entity_type[nentitype]);
       med_int usedbyncs;
       MEDFILESAFECALLERRD0(MEDfieldEntityType,(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types,&usedbyncs));
       std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > entitiesFastP;
       for(int i=0;i<nentitype;i++)
         {
-          int ngeotype(MEDfieldnGeometryType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i]));
+          med_int ngeotype(MEDfieldnGeometryType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i]));
           INTERP_KERNEL::AutoPtr<med_geometry_type> geotypes(new med_geometry_type[ngeotype]);
           med_int geousedbyncs;
           MEDFILESAFECALLERRD0(MEDfieldGeometryType,(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i],geotypes,&geousedbyncs));
-          for(int j=0;j<ngeotype;j++)
+          for(med_int j=0;j<ngeotype;j++)
             {
               std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> p(MEDFileMesh::ConvertFromMEDFileEntity(types[i]),ConvertGeometryType(geotypes[j]));
               entitiesFastP.push_back(p);
index 8ba0edfccac2a49d817a139776d5f5eae28f6619..7beaf1d10c14ce510d129dbd325bfe76ba6cb7fb 100644 (file)
@@ -362,7 +362,7 @@ void MEDFileUMeshPerType::Write(med_idt fid, const std::string& mname, int mdim,
       const MEDCoupling1SGTUMesh *m0(dynamic_cast<const MEDCoupling1SGTUMesh *>(m));
       if(!m0)
         throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::Write : internal error #1 !");
-      MCAuto<DataArrayMedInt> arr(DataArrayMedInt::Copy(m0->getNodalConnectivity()));
+      MCAuto<DataArrayMedInt> arr(DataArrayMedInt_Copy(m0->getNodalConnectivity()));
       std::transform(arr->begin(),arr->end(),arr->getPointer(),std::bind(std::plus<med_int>(),std::placeholders::_1,1));
       MEDFILESAFECALLERWR0(MEDmeshElementConnectivityWr,(fid,mname.c_str(),dt,it,timm,MED_CELL,curMedType,MED_NODAL,MED_FULL_INTERLACE,ToMedInt(nbOfCells),arr->begin()));
     }
@@ -373,7 +373,7 @@ void MEDFileUMeshPerType::Write(med_idt fid, const std::string& mname, int mdim,
         throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::Write : internal error #2 !");
       if(ikt==INTERP_KERNEL::NORM_POLYGON || ikt==INTERP_KERNEL::NORM_QPOLYG)
         {
-          MCAuto<DataArrayMedInt> arr(DataArrayMedInt::Copy(m0->getNodalConnectivity())),arrI(DataArrayMedInt::Copy(m0->getNodalConnectivityIndex()));
+          MCAuto<DataArrayMedInt> arr(DataArrayMedInt_Copy(m0->getNodalConnectivity())),arrI(DataArrayMedInt_Copy(m0->getNodalConnectivityIndex()));
           std::transform(arr->begin(),arr->end(),arr->getPointer(),std::bind(std::plus<med_int>(),std::placeholders::_1,1));
           std::transform(arrI->begin(),arrI->end(),arrI->getPointer(),std::bind(std::plus<med_int>(),std::placeholders::_1,1));
           MEDFILESAFECALLERWR0(MEDmeshPolygon2Wr,(fid,mname.c_str(),dt,it,timm,MED_CELL,ikt==INTERP_KERNEL::NORM_POLYGON?MED_POLYGON:MED_POLYGON2,MED_NODAL,ToMedInt(nbOfCells+1),arrI->begin(),arr->begin()));
index c992c4df06cd378803e117f517eaff9ff6603e25..6720c9503d40ca0060a9e6a8643be1856d928d92 100644 (file)
@@ -522,9 +522,9 @@ void MEDCoupling::GetFamiliesGroupsInfo(const std::string& fileName, const std::
   char nomfam[MED_NAME_SIZE+1];
   for(med_int i=0;i<nbFams;++i)
     {
-      med_int nbGrps(MEDnFamilyGroup(fid,meshName.c_str(),i+1)),famId;
+      med_int nbGrps(MEDnFamilyGroup(fid,meshName.c_str(),FromMedInt<int>(i+1))),famId;
       std::unique_ptr<char[]> gro{new char[MED_LNAME_SIZE*nbGrps+1]};
-      MEDFILESAFECALLERRD0(MEDfamilyInfo,(fid,meshName.c_str(),i+1,nomfam,&famId,gro.get()));
+      MEDFILESAFECALLERRD0(MEDfamilyInfo,(fid,meshName.c_str(),FromMedInt<int>(i+1),nomfam,&famId,gro.get()));
       std::string fam(MEDLoaderBase::buildStringFromFortran(nomfam,MED_NAME_SIZE));
       families[fam] = FromMedInt<mcIdType>(famId);
       std::vector<std::string> v(nbGrps);
index 13d291198fdd8638154d4e8088ee9b978139baa1..59df1555d18e7c394a1ab4348d970c7e5a626036 100644 (file)
@@ -5627,6 +5627,25 @@ class MEDLoaderTest4(unittest.TestCase):
             self.assertTrue(v.isEqual(DataArrayDouble([0.0]),1e-14))
         pass
 
+    @WriteInTmpDir
+    def test43(self):
+        """
+        EDF23724 : point to error during 64bit convertion into medcoupling a DataArrayMedInt class was created.
+                   This class is not dynamic_castable to DataArrayInt32 nor DataArrayInt64. It lead previously to strange behaviour
+        """
+        fname = "tessss.med"
+        arr=DataArrayDouble(10) ; arr.iota()
+        m = MEDCouplingCMesh() ; m.setCoords(arr)
+        m = m.buildUnstructured()
+        m.setName("mesh")
+        mm = MEDFileUMesh() ; mm[0] = m
+        mm.setGlobalNumFieldAtLevel(1,DataArrayInt([0,4,5,6,10,12,16,17,19,20]))
+        mm.write(fname,2)
+        mm_reload = MEDFileMesh.New(fname)
+        # DataArrayMedInt class no more exists. Check that.
+        self.assertNotEqual(mm_reload.getGlobalNumFieldAtLevel(1).getClassName() , "DataArrayMedInt")
+        pass
+
     pass
 
 if __name__ == "__main__":