Salome HOME
bos #20256: [CEA 18523] Porting SMESH to int 64 bits V9_7_0a1 V9_7_0a2 V9_7_0b1
authoreap <eap@opencascade.com>
Wed, 17 Mar 2021 14:11:57 +0000 (17:11 +0300)
committervsr <vsr@opencascade.com>
Tue, 20 Apr 2021 13:04:08 +0000 (16:04 +0300)
225 files changed:
CMakeLists.txt
SalomeSMESHConfig.cmake.in
idl/CMakeLists.txt
idl/SMESH_BasicHypothesis.idl
idl/SMESH_Filter.idl
idl/SMESH_Gen.idl
idl/SMESH_Group.idl
idl/SMESH_Hypothesis.idl
idl/SMESH_Measurements.idl
idl/SMESH_Mesh.idl
idl/SMESH_MeshEditor.idl
idl/SMESH_Pattern.idl
idl/SMESH_smIdType.idl.in [new file with mode: 0644]
src/Controls/SMESH_Controls.cxx
src/Controls/SMESH_ControlsDef.hxx
src/Driver/Driver_Mesh.h
src/DriverCGNS/DriverCGNS_Read.cxx
src/DriverCGNS/DriverCGNS_Write.cxx
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
src/DriverGMF/DriverGMF_Read.cxx
src/DriverGMF/DriverGMF_Write.cxx
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_Field.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
src/DriverUNV/DriverUNV_W_SMDS_Mesh.h
src/MEDWrapper/MED_Common.hxx
src/OBJECT/SMESH_Actor.cxx
src/OBJECT/SMESH_Actor.h
src/OBJECT/SMESH_ActorDef.h
src/OBJECT/SMESH_ActorUtils.cxx
src/OBJECT/SMESH_ActorUtils.h
src/OBJECT/SMESH_CellLabelActor.cxx
src/OBJECT/SMESH_DeviceActor.cxx
src/OBJECT/SMESH_DeviceActor.h
src/OBJECT/SMESH_ExtractGeometry.cxx
src/OBJECT/SMESH_ExtractGeometry.h
src/OBJECT/SMESH_NodeLabelActor.cxx
src/OBJECT/SMESH_Object.cxx
src/OBJECT/SMESH_Object.h
src/OBJECT/SMESH_ObjectDef.h
src/OBJECT/SMESH_SVTKActor.cxx
src/OBJECT/SMESH_SVTKActor.h
src/SMDS/SMDS_BallElement.cxx
src/SMDS/SMDS_CellOfNodes.cxx
src/SMDS/SMDS_CellOfNodes.hxx
src/SMDS/SMDS_Downward.cxx
src/SMDS/SMDS_ElementFactory.cxx
src/SMDS/SMDS_ElementFactory.hxx
src/SMDS/SMDS_ElementHolder.cxx
src/SMDS/SMDS_ElementHolder.hxx
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMDS/SMDS_MeshCell.cxx
src/SMDS/SMDS_MeshElement.cxx
src/SMDS/SMDS_MeshElement.hxx
src/SMDS/SMDS_MeshGroup.hxx
src/SMDS/SMDS_MeshInfo.hxx
src/SMDS/SMDS_MeshNode.cxx
src/SMDS/SMDS_MeshVolume.cxx
src/SMDS/SMDS_UnstructuredGrid.cxx
src/SMDS/SMDS_UnstructuredGrid.hxx
src/SMDS/SMDS_VolumeTool.cxx
src/SMDS/SMDS_VolumeTool.hxx
src/SMDS/SMDS_VtkCellIterator.cxx
src/SMDS/SMDS_VtkCellIterator.hxx
src/SMESH/SMESH_Algo.cxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESH/SMESH_MeshEditor.cxx
src/SMESH/SMESH_MeshEditor.hxx
src/SMESH/SMESH_MesherHelper.cxx
src/SMESH/SMESH_MesherHelper.hxx
src/SMESH/SMESH_Pattern.cxx
src/SMESH/SMESH_ProxyMesh.cxx
src/SMESH/SMESH_ProxyMesh.hxx
src/SMESH/SMESH_subMesh.cxx
src/SMESHClient/SMESH_Client.cxx
src/SMESHDS/SMESHDS_Command.cxx
src/SMESHDS/SMESHDS_Command.hxx
src/SMESHDS/SMESHDS_Group.cxx
src/SMESHDS/SMESHDS_Group.hxx
src/SMESHDS/SMESHDS_GroupBase.cxx
src/SMESHDS/SMESHDS_GroupBase.hxx
src/SMESHDS/SMESHDS_GroupOnFilter.cxx
src/SMESHDS/SMESHDS_GroupOnFilter.hxx
src/SMESHDS/SMESHDS_GroupOnGeom.cxx
src/SMESHDS/SMESHDS_GroupOnGeom.hxx
src/SMESHDS/SMESHDS_Mesh.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHDS/SMESHDS_Script.cxx
src/SMESHDS/SMESHDS_Script.hxx
src/SMESHDS/SMESHDS_SubMesh.cxx
src/SMESHDS/SMESHDS_SubMesh.hxx
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI_Add0DElemsOnAllNodesDlg.cxx
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
src/SMESHGUI/SMESHGUI_ComputeDlg.h
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
src/SMESHGUI/SMESHGUI_CopyMeshDlg.cxx
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_DisplayEntitiesDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionAlongPathDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionDlg.cxx
src/SMESHGUI/SMESHGUI_ExtrusionDlg.h
src/SMESHGUI/SMESHGUI_Filter.cxx
src/SMESHGUI/SMESHGUI_Filter.h
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
src/SMESHGUI/SMESHGUI_FilterDlg.h
src/SMESHGUI/SMESHGUI_FindElemByPointDlg.cxx
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
src/SMESHGUI/SMESHGUI_IdPreview.cxx
src/SMESHGUI/SMESHGUI_IdPreview.h
src/SMESHGUI/SMESHGUI_MakeNodeAtPointDlg.cxx
src/SMESHGUI/SMESHGUI_Measurements.cxx
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
src/SMESHGUI/SMESHGUI_MergeDlg.h
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
src/SMESHGUI/SMESHGUI_MeshInfosBox.cxx
src/SMESHGUI/SMESHGUI_MeshInfosBox.h
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
src/SMESHGUI/SMESHGUI_MultiEditDlg.h
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
src/SMESHGUI/SMESHGUI_OffsetDlg.cxx
src/SMESHGUI/SMESHGUI_PreVisualObj.cxx
src/SMESHGUI/SMESHGUI_PreVisualObj.h
src/SMESHGUI/SMESHGUI_RemoveElementsDlg.cxx
src/SMESHGUI/SMESHGUI_RemoveNodesDlg.cxx
src/SMESHGUI/SMESHGUI_ReorientFacesDlg.cxx
src/SMESHGUI/SMESHGUI_RevolutionDlg.cxx
src/SMESHGUI/SMESHGUI_RotationDlg.cxx
src/SMESHGUI/SMESHGUI_ScaleDlg.cxx
src/SMESHGUI/SMESHGUI_SelectionOp.cxx
src/SMESHGUI/SMESHGUI_SelectionOp.h
src/SMESHGUI/SMESHGUI_SelectionProxy.cxx
src/SMESHGUI/SMESHGUI_SelectionProxy.h
src/SMESHGUI/SMESHGUI_SewingDlg.cxx
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.cxx
src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx
src/SMESHGUI/SMESHGUI_SmoothingDlg.cxx
src/SMESHGUI/SMESHGUI_SymmetryDlg.cxx
src/SMESHGUI/SMESHGUI_TranslationDlg.cxx
src/SMESHGUI/SMESHGUI_TransparencyDlg.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.h
src/SMESHUtils/SMESH_Delaunay.hxx
src/SMESHUtils/SMESH_MeshAlgos.cxx
src/SMESHUtils/SMESH_OctreeNode.hxx
src/SMESHUtils/SMESH_Offset.cxx
src/SMESHUtils/SMESH_Slot.cxx
src/SMESHUtils/SMESH_TryCatch.hxx
src/SMESHUtils/SMESH_TypeDefs.hxx
src/SMESH_I/SMESH_Filter_i.cxx
src/SMESH_I/SMESH_Filter_i.hxx
src/SMESH_I/SMESH_Gen_i.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Gen_i_1.cxx
src/SMESH_I/SMESH_Group_i.cxx
src/SMESH_I/SMESH_Group_i.hxx
src/SMESH_I/SMESH_Hypothesis_i.cxx
src/SMESH_I/SMESH_Hypothesis_i.hxx
src/SMESH_I/SMESH_Measurements_i.cxx
src/SMESH_I/SMESH_MeshEditor_i.cxx
src/SMESH_I/SMESH_MeshEditor_i.hxx
src/SMESH_I/SMESH_MeshPartDS.hxx
src/SMESH_I/SMESH_Mesh_i.cxx
src/SMESH_I/SMESH_Mesh_i.hxx
src/SMESH_I/SMESH_Pattern_i.cxx
src/SMESH_I/SMESH_Pattern_i.hxx
src/SMESH_I/SMESH_PreMeshInfo.cxx
src/SMESH_I/SMESH_PreMeshInfo.hxx
src/SMESH_I/SMESH_PythonDump.cxx
src/SMESH_I/SMESH_PythonDump.hxx
src/SMESH_I/SMESH_subMesh_i.cxx
src/SMESH_I/SMESH_subMesh_i.hxx
src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx
src/StdMeshers/StdMeshers_AutomaticLength.cxx
src/StdMeshers/StdMeshers_CartesianParameters3D.cxx
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
src/StdMeshers/StdMeshers_Distribution.cxx
src/StdMeshers/StdMeshers_Distribution.hxx
src/StdMeshers/StdMeshers_FaceSide.cxx
src/StdMeshers/StdMeshers_FaceSide.hxx
src/StdMeshers/StdMeshers_FixedPoints1D.cxx
src/StdMeshers/StdMeshers_FixedPoints1D.hxx
src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
src/StdMeshers/StdMeshers_Hexa_3D.cxx
src/StdMeshers/StdMeshers_Import_1D.cxx
src/StdMeshers/StdMeshers_Import_1D2D.cxx
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
src/StdMeshers/StdMeshers_NumberOfSegments.cxx
src/StdMeshers/StdMeshers_NumberOfSegments.hxx
src/StdMeshers/StdMeshers_Penta_3D.cxx
src/StdMeshers/StdMeshers_PolygonPerFace_2D.cxx
src/StdMeshers/StdMeshers_PolyhedronPerSolid_3D.cxx
src/StdMeshers/StdMeshers_Prism_3D.cxx
src/StdMeshers/StdMeshers_Prism_3D.hxx
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
src/StdMeshers/StdMeshers_Projection_1D.cxx
src/StdMeshers/StdMeshers_Projection_1D2D.cxx
src/StdMeshers/StdMeshers_Projection_2D.cxx
src/StdMeshers/StdMeshers_Projection_3D.cxx
src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
src/StdMeshers/StdMeshers_RadialPrism_3D.cxx
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
src/StdMeshers/StdMeshers_Regular_1D.cxx
src/StdMeshers/StdMeshers_Regular_1D.hxx
src/StdMeshers/StdMeshers_ViscousLayers.cxx
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.cxx
src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.h
src/StdMeshersGUI/StdMeshersGUI_ObjectReferenceParamWdg.h
src/StdMeshersGUI/StdMeshersGUI_QuadrangleParamWdg.cxx
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.cxx
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.hxx

index bafa46d..b322f2b 100644 (file)
@@ -79,6 +79,12 @@ IF(SALOME_SMESH_DYNLOAD_LOCAL)
   ADD_DEFINITIONS(-DDYNLOAD_LOCAL)
 ENDIF(SALOME_SMESH_DYNLOAD_LOCAL)
 
+IF(SALOME_USE_64BIT_IDS)
+   SET(SMESH_ID_TYPE "long long")
+ELSE()
+   SET(SMESH_ID_TYPE "long")
+ENDIF()
+
 IF(SMESH_USE_MESHGEMS_HYPOSET)
   SET(SMESH_USE_MESHGEMS_HYPOSET_VAR "true")
 ELSE(SMESH_USE_MESHGEMS_HYPOSET)
index 70fe121..045516b 100644 (file)
@@ -127,6 +127,7 @@ SET(SALOME_INSTALL_PYTHON_SHARED "@SALOME_INSTALL_PYTHON_SHARED@")
 SET(SALOME_INSTALL_RES "@SALOME_INSTALL_RES@")
 SET(SALOME_INSTALL_DOC "@SALOME_INSTALL_DOC@")
 SET(SALOME_INSTALL_AMCONFIG_LOCAL "@SALOME_INSTALL_AMCONFIG_LOCAL@")
+SET(SALOME_USE_64BIT_IDS  @SALOME_USE_64BIT_IDS@)
 
 # Include GEOM targets if they were not already loaded:
 IF(NOT (TARGET GEOMbasic))
index 7953664..bd2569e 100644 (file)
@@ -26,6 +26,8 @@ INCLUDE_DIRECTORIES(
   ${PROJECT_BINARY_DIR}/idl
 )
 
+SALOME_CONFIGURE_FILE(SMESH_smIdType.idl.in SMESH_smIdType.idl)
+
 SET(SalomeIDLSMESH_IDLSOURCES
   SMESH_Gen.idl
   SMESH_Mesh.idl
@@ -36,12 +38,14 @@ SET(SalomeIDLSMESH_IDLSOURCES
   SMESH_Pattern.idl
   SMESH_MeshEditor.idl
   SMESH_Measurements.idl
+  ${CMAKE_CURRENT_BINARY_DIR}/SMESH_smIdType.idl
   MG_ADAPT.idl
 )
 
 SET(_idl_include_dirs
   ${KERNEL_ROOT_DIR}/idl/salome
   ${GEOM_ROOT_DIR}/idl/salome
+  ${PROJECT_BINARY_DIR}/idl
 )
 
 SET(_idl_link_flags
index a60b3c2..5dbdc5f 100644 (file)
@@ -161,32 +161,32 @@ module StdMeshers
     /*!
      * Builds and returns point distribution according to passed density function
      */
-    SMESH::double_array BuildDistributionExpr( in string func, in long nbSeg, in long conv )
+    SMESH::double_array BuildDistributionExpr( in string func, in long nbSeg, in long  conv )
       raises (SALOME::SALOME_Exception);
-    SMESH::double_array BuildDistributionTab( in SMESH::double_array func, in long nbSeg, in long conv )
+    SMESH::double_array BuildDistributionTab( in SMESH::double_array func, in long  nbSeg, in long  conv )
       raises (SALOME::SALOME_Exception);
   
     /*!
      * Sets <number of segments> parameter value
      */
-    void SetNumberOfSegments(in long segmentsNumber)
+    void SetNumberOfSegments(in SMESH::smIdType  segmentsNumber)
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Returns <number of segments> parameter value
      */
-    long GetNumberOfSegments();
+    long  GetNumberOfSegments();
 
     /*!
      * Sets <distribution type> parameter value
      */
-    void SetDistrType(in long typ)
+    void SetDistrType(in long  typ)
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Returns <distribution type> parameter value
      */
-    long GetDistrType();
+    long  GetDistrType();
 
     /*!
      * Sets <scale factor> parameter value
@@ -227,13 +227,13 @@ module StdMeshers
     /*!
      * Sets <conversion mode> parameter value for functional distributions
      */
-    void SetConversionMode(in long conv )
+    void SetConversionMode(in long  conv )
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Returns <conversion mode> parameter value for functional distributions
      */
-    long ConversionMode()
+    long  ConversionMode()
       raises (SALOME::SALOME_Exception);
   };
 
@@ -323,13 +323,13 @@ module StdMeshers
     /*!
      * Sets <mode> parameter value
      */
-    void SetMode(in long mode) 
+    void SetMode(in long  mode) 
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Returns <mode> parameter value
      */
-    long GetMode();
+    long  GetMode();
   };
 
   /*!
@@ -395,7 +395,7 @@ module StdMeshers
      */
     void SetPoints(in SMESH::double_array listParams) 
       raises (SALOME::SALOME_Exception);
-    void SetNbSegments(in SMESH::long_array listNbSeg) 
+    void SetNbSegments(in SMESH::smIdType_array listNbSeg)
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -406,7 +406,7 @@ module StdMeshers
     /*!
      * Returns list of numbers of segments
      */
-    SMESH::long_array GetNbSegments();
+    SMESH::smIdType_array GetNbSegments();
 
   };
 
@@ -519,13 +519,13 @@ module StdMeshers
     /*!
      * Sets <number of segments> parameter value
      */
-    void SetNumberOfLayers(in long numberOfLayers) 
+    void SetNumberOfLayers(in long  numberOfLayers) 
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Returns <number of layers> parameter value
      */
-    long GetNumberOfLayers();
+    long  GetNumberOfLayers();
 
   };
 
@@ -665,7 +665,7 @@ module StdMeshers
      * Result may be nil if association not set.
      * Valid indices are 1 and 2
      */
-    GEOM::GEOM_Object  GetSourceVertex(in long i)
+    GEOM::GEOM_Object  GetSourceVertex(in long  i)
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -673,7 +673,7 @@ module StdMeshers
      * Result may be nil if association not set.
      * Valid indices are 1 and 2
      */
-    GEOM::GEOM_Object  GetTargetVertex(in long i)
+    GEOM::GEOM_Object  GetTargetVertex(in long  i)
       raises (SALOME::SALOME_Exception);
   };
 
@@ -722,7 +722,7 @@ module StdMeshers
      * Result may be nil if association not set.
      * Valid indices are 1 and 2
      */
-    GEOM::GEOM_Object  GetSourceVertex(in long i)
+    GEOM::GEOM_Object  GetSourceVertex(in long  i)
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -730,7 +730,7 @@ module StdMeshers
      * Result may be nil if association not set.
      * Valid indices are 1 and 2
      */
-    GEOM::GEOM_Object  GetTargetVertex(in long i)
+    GEOM::GEOM_Object  GetTargetVertex(in long  i)
       raises (SALOME::SALOME_Exception);
   };
 
@@ -771,12 +771,12 @@ module StdMeshers
     /*!
      * Set base vertex for triangles
      */
-    void SetTriaVertex( in long vertID );
+    void SetTriaVertex( in long  vertID );
     
     /*!
      * Returns base vertex for triangles
      */
-    long GetTriaVertex();
+    long  GetTriaVertex();
     
     /*!
      * Set entry of the main object
index b8a4a89..daca385 100644 (file)
@@ -30,6 +30,7 @@
 #include "SALOME_GenericObj.idl"
 #include "GEOM_Gen.idl"
 #include "SMESH_Mesh.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -119,8 +120,8 @@ module SMESH
   */
   interface NumericalFunctor: Functor
   {
-    double  GetValue    ( in long theElementId );
-    boolean IsApplicable( in long theElementId );
+    double  GetValue    ( in smIdType theElementId );
+    boolean IsApplicable( in smIdType theElementId );
 
     Histogram GetHistogram     ( in short nbIntervals, in boolean isLogarithmic );
     Histogram GetLocalHistogram( in short nbIntervals, in boolean isLogarithmic,
@@ -374,7 +375,7 @@ module SMESH
   */
   interface RangeOfIds: Predicate
   {
-    void            SetRange( in long_array theIds );
+    void            SetRange( in smIdType_array theIds );
     boolean         SetRangeStr( in string theRange );
     string          GetRangeStr();
 
@@ -474,7 +475,7 @@ module SMESH
     void            SetElementType( in ElementType type );
     void            SetPoint      ( in double x, in double y, in double z );
     void            SetVertex     ( in GEOM::GEOM_Object vertex );
-    void            SetNode       ( in long nodeID );
+    void            SetNode       ( in smIdType nodeID );
     string          GetThreshold  ( out ThresholdType type );
     void            SetThreshold  ( in string threshold, in ThresholdType type ) 
       raises (SALOME::SALOME_Exception);
@@ -522,16 +523,16 @@ module SMESH
 
     typedef sequence<Criterion> Criteria;
 
-    void          SetPredicate( in Predicate thePredicate );
-    void          SetMesh( in SMESH_Mesh theMesh );
+    void           SetPredicate( in Predicate thePredicate );
+    void           SetMesh( in SMESH_Mesh theMesh );
 
-    long_array    GetElementsId( in SMESH_Mesh theMesh );
-    long_array    GetElementsIdFromParts( in ListOfIDSources theParts );
-    ElementType   GetElementType();
-    Predicate     GetPredicate();
+    smIdType_array GetElementsId( in SMESH_Mesh theMesh );
+    smIdType_array GetElementsIdFromParts( in ListOfIDSources theParts );
+    ElementType    GetElementType();
+    Predicate      GetPredicate();
 
-    boolean       GetCriteria( out Criteria theCriteria );
-    boolean       SetCriteria( in Criteria theCriteria );
+    boolean        GetCriteria( out Criteria theCriteria );
+    boolean        SetCriteria( in Criteria theCriteria );
   };
 
 
index ffeb15e..eeb8f0c 100644 (file)
@@ -33,6 +33,7 @@
 
 #include "SMESH_Mesh.idl"
 #include "SMESH_Hypothesis.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -387,8 +388,8 @@ module SMESH
     /*!
      * Evaluates size of prospective mesh on a shape
      */
-    long_array  Evaluate(in SMESH_Mesh        theMesh,
-                         in GEOM::GEOM_Object theSubObject)
+    smIdType_array  Evaluate(in SMESH_Mesh        theMesh,
+                             in GEOM::GEOM_Object theSubObject)
       raises ( SALOME::SALOME_Exception );
 
     /*!
@@ -446,17 +447,17 @@ module SMESH
      * The returned geometrical object, if not nil, is either found in the
      * study or is published by this method with the given name
      */
-    GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh  theMesh,
-                                                in long        theElementID,
-                                                in string      theGeomName)
+    GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
+                                                in smIdType   theElementID,
+                                                in string     theGeomName)
       raises ( SALOME::SALOME_Exception );
 
     /*!
      * Return geometrical object the given element is built on.
      * The returned geometrical object not published in study by this method.
      */
-    GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh  theMesh,
-                                                 in long        theElementID)
+    GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
+                                                 in smIdType   theElementID)
       raises ( SALOME::SALOME_Exception );
 
     /*!
index e34cc96..8730c1a 100644 (file)
@@ -32,6 +32,7 @@
 #include "SALOMEDS_Attributes.idl"
 
 #include "SMESH_Mesh.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -61,7 +62,7 @@ module SMESH
     /*!
      * Returns the number of elements in the group
      */
-    long Size();
+    smIdType Size();
 
     /*!
      * Returns true if the group does not contain any elements
@@ -71,29 +72,29 @@ module SMESH
     /*!
      * returns true if the group contains an element with ID == <elem_id> 
      */
-    boolean Contains( in long elem_id );
+    boolean Contains( in smIdType elem_id );
 
     /*!
      * Returns ID of an element at position <elem_index> counted from 1
      */
-    long GetID( in long elem_index );
+    smIdType GetID( in smIdType elem_index );
 
     /*!
      * Returns a sequence of all element IDs in the group
      */
-    long_array GetListOfID();
+    smIdType_array GetListOfID();
 
     /*!
      * Get the number of nodes of cells included to the group
      * For a nodal group returns the same value as Size() function
      */
-    long GetNumberOfNodes();
+    smIdType GetNumberOfNodes();
 
     /*!
      * Get IDs of nodes of cells included to the group
      * For a nodal group returns result of GetListOfID() function
      */
-    long_array GetNodeIDs();
+    smIdType_array GetNodeIDs();
 
     /*!
      * Return true if GetNumberOfNodes() won't take a long time for computation
@@ -142,24 +143,24 @@ module SMESH
     /*!
      * Adds elements or nodes with specified identifiers to the group
      */
-    long Add( in long_array elem_ids );
+    smIdType Add( in smIdType_array elem_ids );
     /*!
      * Adds elements or nodes that match specified predicate to the group
      */
-    long AddByPredicate( in Predicate thePredicate );
+    smIdType AddByPredicate( in Predicate thePredicate );
     /*!
      * Add all elements or nodes from the specified source to the group
      */
-    long AddFrom( in SMESH_IDSource theSource );
+    smIdType AddFrom( in SMESH_IDSource theSource );
 
     /*!
      * Removes elements or nodes with specified identifiers from the group
      */
-    long Remove( in long_array elem_ids );
+    smIdType Remove( in smIdType_array elem_ids );
     /*!
      * Removes elements or nodes that match specified predicate from the group
      */
-    long RemoveByPredicate( in Predicate thePredicate );
+    smIdType RemoveByPredicate( in Predicate thePredicate );
 
   };
 
index bc413d7..80f76bf 100644 (file)
@@ -57,7 +57,7 @@ module SMESH
     /*!
      * Get the internal Id 
      */
-    long GetId();
+    short GetId();
 
     /*!
      *  Set the variable parameter
index 8962e79..e696976 100644 (file)
@@ -28,6 +28,7 @@
 
 #include "SALOME_GenericObj.idl"
 #include "SMESH_Mesh.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -37,8 +38,8 @@ module SMESH
   struct Measure {
     double minX, minY, minZ;
     double maxX, maxY, maxZ;
-    long node1, node2;
-    long elem1, elem2;
+    smIdType node1, node2;
+    smIdType elem1, elem2;
     double value;
   };
 
index 5597f5b..2ff478b 100644 (file)
@@ -29,6 +29,7 @@
 #include "SALOME_Exception.idl"
 #include "SALOME_GenericObj.idl"
 #include "GEOM_Gen.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -41,6 +42,7 @@ module SMESH
 
   typedef sequence<double    > double_array ;
   typedef sequence<long      > long_array ;
+  typedef sequence<smIdType  > smIdType_array ;
   typedef sequence<string    > string_array ;
   typedef sequence<long_array> array_of_long_array ;
 
@@ -228,12 +230,12 @@ module SMESH
   enum DriverMED_ReadStatus // in the order of severity
   {
     DRS_OK,
-    DRS_EMPTY,          // a file contains no mesh with the given name
-    DRS_WARN_RENUMBER,  // a MED file has overlapped ranges of element numbers,
-                        // so the numbers from the file are ignored
-    DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
+    DRS_EMPTY,           // a file contains no mesh with the given name
+    DRS_WARN_RENUMBER,   // a MED file has overlapped ranges of element numbers,
+                         // so the numbers from the file are ignored
+    DRS_WARN_SKIP_ELEM,  // some elements were skipped due to incorrect file data
     DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
-    DRS_FAIL            // general failure (exception etc.)
+    DRS_FAIL             // general failure (exception etc.)
   };
 
   /*! 
@@ -267,7 +269,7 @@ module SMESH
    */
   struct ElementSubType { ElementType SMDS_ElementType;
                           boolean     isPoly;
-                          long        nbNodesInElement; };
+                          short       nbNodesInElement; };
 
   typedef sequence<ElementSubType> types_array;
 
@@ -285,19 +287,19 @@ module SMESH
     /*!
      * Returns a sequence of all element IDs
      */
-    long_array GetIDs();
+    smIdType_array GetIDs();
 
     /*!
      * Returns number of mesh elements of each \a EntityType
      * @return array of number of elements per \a EntityType
      */
-    long_array GetMeshInfo();
+    smIdType_array GetMeshInfo();
 
     /*!
      * Returns number of mesh elements of each \a ElementType
      * @return array of number of elements per \a ElementType
      */
-    long_array GetNbElementsByType();
+    smIdType_array GetNbElementsByType();
 
     /*!
      * Returns types of elements it contains.
@@ -747,121 +749,121 @@ module SMESH
     /*!
      * Get information about mesh contents
      */
-    long NbNodes()
+    smIdType NbNodes()
       raises (SALOME::SALOME_Exception);
 
-    long NbElements()
+    smIdType NbElements()
       raises (SALOME::SALOME_Exception);
 
-    long Nb0DElements()
+    smIdType Nb0DElements()
       raises (SALOME::SALOME_Exception);
 
-    long NbBalls()
+    smIdType NbBalls()
       raises (SALOME::SALOME_Exception);
 
-    long NbEdges()
+    smIdType NbEdges()
       raises (SALOME::SALOME_Exception);
 
-    long NbEdgesOfOrder(in ElementOrder order)
+    smIdType NbEdgesOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbFaces()
+    smIdType NbFaces()
       raises (SALOME::SALOME_Exception);
 
-    long NbFacesOfOrder(in ElementOrder order)
+    smIdType NbFacesOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbTriangles()
+    smIdType NbTriangles()
       raises (SALOME::SALOME_Exception);
 
-    long NbTrianglesOfOrder(in ElementOrder order)
+    smIdType NbTrianglesOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbBiQuadTriangles()
+    smIdType NbBiQuadTriangles()
       raises (SALOME::SALOME_Exception);
 
-    long NbQuadrangles()
+    smIdType NbQuadrangles()
       raises (SALOME::SALOME_Exception);
 
-    long NbQuadranglesOfOrder(in ElementOrder order)
+    smIdType NbQuadranglesOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbBiQuadQuadrangles()
+    smIdType NbBiQuadQuadrangles()
       raises (SALOME::SALOME_Exception);
 
-    long NbPolygons()
+    smIdType NbPolygons()
       raises (SALOME::SALOME_Exception);
 
-    long NbPolygonsOfOrder(in ElementOrder order)
+    smIdType NbPolygonsOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbVolumes()
+    smIdType NbVolumes()
       raises (SALOME::SALOME_Exception);
 
-    long NbVolumesOfOrder(in ElementOrder order)
+    smIdType NbVolumesOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbTetras()
+    smIdType NbTetras()
       raises (SALOME::SALOME_Exception);
 
-    long NbTetrasOfOrder(in ElementOrder order)
+    smIdType NbTetrasOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbHexas()
+    smIdType NbHexas()
       raises (SALOME::SALOME_Exception);
 
-    long NbHexasOfOrder(in ElementOrder order)
+    smIdType NbHexasOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbTriQuadraticHexas()
+    smIdType NbTriQuadraticHexas()
       raises (SALOME::SALOME_Exception);
 
-    long NbPyramids()
+    smIdType NbPyramids()
       raises (SALOME::SALOME_Exception);
 
-    long NbPyramidsOfOrder(in ElementOrder order)
+    smIdType NbPyramidsOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbPrisms()
+    smIdType NbPrisms()
       raises (SALOME::SALOME_Exception);
 
-    long NbPrismsOfOrder(in ElementOrder order)
+    smIdType NbPrismsOfOrder(in ElementOrder order)
       raises (SALOME::SALOME_Exception);
 
-    long NbHexagonalPrisms()
+    smIdType NbHexagonalPrisms()
       raises (SALOME::SALOME_Exception);
 
-    long NbPolyhedrons()
+    smIdType NbPolyhedrons()
       raises (SALOME::SALOME_Exception);
 
-    long NbSubMesh()
+    smIdType NbSubMesh()
       raises (SALOME::SALOME_Exception);
 
-    long_array GetElementsId()
+    smIdType_array GetElementsId()
       raises (SALOME::SALOME_Exception);
 
-    long_array GetElementsByType( in ElementType theType )
+    smIdType_array GetElementsByType( in ElementType theType )
       raises (SALOME::SALOME_Exception);
 
-    long_array GetNodesId()
+    smIdType_array GetNodesId()
       raises (SALOME::SALOME_Exception);
     
     /*!
      * Returns type of mesh element
      */    
-    ElementType GetElementType( in long id, in boolean iselem )
+    ElementType GetElementType( in smIdType id, in boolean iselem )
       raises (SALOME::SALOME_Exception);
 
-    EntityType GetElementGeomType( in long id )
+    EntityType GetElementGeomType( in smIdType id )
       raises (SALOME::SALOME_Exception);
 
-    GeometryType GetElementShape( in long id )
+    GeometryType GetElementShape( in smIdType id )
       raises (SALOME::SALOME_Exception);
 
-    long_array GetSubMeshElementsId(in long ShapeID)
+    smIdType_array GetSubMeshElementsId(in long ShapeID)
       raises (SALOME::SALOME_Exception);
 
-    long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
+    smIdType_array GetSubMeshNodesId(in long ShapeID, in boolean all )
       raises (SALOME::SALOME_Exception);
     
     ElementType GetSubMeshElementType(in long ShapeID)
@@ -902,81 +904,81 @@ module SMESH
      * Get XYZ coordinates of node as list of double
      * If there is not node for given ID - returns empty list
      */
-    double_array GetNodeXYZ(in long id);
+    double_array GetNodeXYZ(in smIdType id);
 
     /*!
      * For given node returns list of IDs of inverse elements
      * If there is not node for given ID - returns empty list
      */
-    long_array GetNodeInverseElements(in long id, in ElementType elemType);
+    smIdType_array GetNodeInverseElements(in smIdType id, in ElementType elemType);
 
     /*!
      * \brief Return position of a node on shape
      */
-    NodePosition GetNodePosition(in long NodeID);
+    NodePosition GetNodePosition(in smIdType NodeID);
 
     /*!
      * \brief Return position of an element on shape
      */
-    ElementPosition GetElementPosition(in long ElemID);
+    ElementPosition GetElementPosition(in smIdType ElemID);
 
     /*!
      * If given element is node returns IDs of shape from position
      * If there is not node for given ID - returns -1
      */
-    long GetShapeID(in long id);
+    long GetShapeID(in smIdType id);
 
     /*!
      * For given element returns ID of result shape after 
      * ::FindShape() from SMESH_MeshEditor
      * If there is not element for given ID - returns -1
      */
-    long GetShapeIDForElem(in long id);
+    long GetShapeIDForElem(in smIdType id);
 
     /*!
      * Returns number of nodes for given element
      * If there is not element for given ID - returns -1
      */
-    long GetElemNbNodes(in long id);
+    short GetElemNbNodes(in smIdType id);
 
     /*!
      * Returns IDs of nodes of given element
      */
-    long_array GetElemNodes(in long id);
+    smIdType_array GetElemNodes(in smIdType id);
 
     /*!
      * Returns ID of node by given index for given element
      * If there is not element for given ID - returns -1
      * If there is not node for given index - returns -2
      */
-    long GetElemNode(in long id, in long index);
+    smIdType GetElemNode(in smIdType id, in short index);
 
     /*!
      * Returns true if given node is medium node
      * in given quadratic element
      */
-    boolean IsMediumNode(in long ide, in long idn);
+    boolean IsMediumNode(in smIdType ide, in smIdType idn);
 
     /*!
      * Returns true if given node is medium node
      * in one of quadratic elements
      */
-    boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
+    boolean IsMediumNodeOfAnyElem(in smIdType idn, in ElementType elem_type);
 
     /*!
      * Returns number of edges for given element
      */
-    long ElemNbEdges(in long id);
+    long ElemNbEdges(in smIdType id);
 
     /*!
      * Returns number of faces for given element
      */
-    long ElemNbFaces(in long id);
+    long ElemNbFaces(in smIdType id);
 
     /*!
      * Returns nodes of given face (counted from zero) for given volumic element.
      */
-    long_array GetElemFaceNodes(in long elemId, in short faceIndex);
+    smIdType_array GetElemFaceNodes(in smIdType elemId, in short faceIndex);
 
     /*!
      * Returns three components of normal of given mesh face (or an empty array in KO case)
@@ -986,34 +988,34 @@ module SMESH
     /*!
      * Returns an element based on all given nodes.
      */
-    long FindElementByNodes(in long_array nodes);
+    smIdType FindElementByNodes(in smIdType_array nodes);
 
     /*!
      * Return elements including all given nodes.
      */
-    long_array GetElementsByNodes(in long_array nodes, in ElementType elem_type);
+    smIdType_array GetElementsByNodes(in smIdType_array nodes, in ElementType elem_type);
 
     /*!
      * Returns true if given element is polygon
      */
-    boolean IsPoly(in long id);
+    boolean IsPoly(in smIdType id);
 
     /*!
      * Returns true if given element is quadratic
      */
-    boolean IsQuadratic(in long id);
+    boolean IsQuadratic(in smIdType id);
 
     /*!
      * Returns diameter of a ball discrete element or zero in case of an invalid \a id
      */
-    double GetBallDiameter(in long id);
+    double GetBallDiameter(in smIdType id);
 
     /*!
      * Returns XYZ coordinates of bary center for given element
      * as list of double
      * If there is not element for given ID - returns empty list
      */
-    double_array BaryCenter(in long id);
+    double_array BaryCenter(in smIdType id);
 
     /*! Gets information about imported MED file */
     MedFileInfo GetMEDFileInfo();
@@ -1040,37 +1042,37 @@ module SMESH
     /*!
      *
      */
-    long GetNumberOfElements()
+    smIdType GetNumberOfElements()
       raises (SALOME::SALOME_Exception);
 
     /*!
      *
      */
-    long GetNumberOfNodes( in boolean all )
+    smIdType GetNumberOfNodes( in boolean all )
       raises (SALOME::SALOME_Exception);
 
     /*!
      *
      */
-    long_array GetElementsId()
+    smIdType_array GetElementsId()
       raises (SALOME::SALOME_Exception);
 
     /*!
      *
      */
-    long_array GetElementsByType( in ElementType theType )
+    smIdType_array GetElementsByType( in ElementType theType )
       raises (SALOME::SALOME_Exception);
     
     /*!
      * Returns type of mesh element (same as SMESH_Mesh::GetElementType() )
      */
-    ElementType GetElementType( in long id, in boolean iselem )
+    ElementType GetElementType( in smIdType id, in boolean iselem )
       raises (SALOME::SALOME_Exception);
 
     /*!
      *
      */
-    long_array GetNodesId()
+    smIdType_array GetNodesId()
       raises (SALOME::SALOME_Exception);
 
     /*!
index d41d1dc..26e73df 100644 (file)
@@ -26,6 +26,7 @@
 
 #include "SMESH_Mesh.idl"
 #include "SMESH_Gen.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -36,7 +37,7 @@ module SMESH
 
   struct FreeBorder
   {
-    SMESH::long_array nodeIDs; // all nodes defining a free border
+    SMESH::smIdType_array nodeIDs; // all nodes defining a free border
     // 1st and last node is same in a closed border
   };
   struct FreeBorderPart
@@ -66,13 +67,13 @@ module SMESH
     // else                             ==> point is at xyz*
 
     // point 1
-    long node1ID1;
-    long node1ID2;
+    smIdType node1ID1;
+    smIdType node1ID2;
     PointStruct xyz1;
 
     // point 2
-    long node2ID1;
-    long node2ID2;
+    smIdType node2ID1;
+    smIdType node2ID2;
     PointStruct xyz2;
 
     // vector on the plane; to use a default plane set vector = (0,0,0)
@@ -83,9 +84,9 @@ module SMESH
   // face edge defined by two nodes + optional medium node
   struct FaceEdge
   {
-    long node1;
-    long node2;
-    long medium;
+    smIdType node1;
+    smIdType node2;
+    smIdType medium;
   };
   typedef sequence<FaceEdge> ListOfEdges;
 
@@ -112,14 +113,14 @@ module SMESH
     * created, this method returns list of their IDs, if new nodes
     * not created - returns empty list
     */
-    long_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
+    smIdType_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
 
    /*!
     * If during last operation of MeshEditor some elements were
     * created, this method returns list of their IDs, if new elements
     * not created - returns empty list
     */
-    long_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
+    smIdType_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
 
     /*!
      * \brief Clears sequences of last created elements and nodes 
@@ -136,27 +137,27 @@ module SMESH
      * \param IDsOfElements list of mesh elements identifiers
      * \return new ID source object
      */
-    SMESH_IDSource MakeIDSource(in long_array IDsOfElements, in ElementType type);
+    SMESH_IDSource MakeIDSource(in smIdType_array IDsOfElements, in ElementType type);
 
     /*!
      * \brief Remove mesh elements specified by their identifiers.
      * \param IDsOfElements list of mesh elements identifiers
      * \return \c true if elements are correctly removed or \c false otherwise
      */
-    boolean RemoveElements(in long_array IDsOfElements) raises (SALOME::SALOME_Exception);
+    boolean RemoveElements(in smIdType_array IDsOfElements) raises (SALOME::SALOME_Exception);
 
     /*!
      * \brief Remove mesh nodes specified by their identifiers.
      * \param IDsOfNodes list of mesh nodes identifiers
      * \return \c true if nodes are correctly removed or \c false otherwise
      */
-    boolean RemoveNodes(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
+    boolean RemoveNodes(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 
     /*!
      * \brief Remove all orphan nodes.
      * \return number of removed nodes
      */
-    long RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
+    smIdType RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
 
     /*!
      * \brief Add a new node.
@@ -165,21 +166,21 @@ module SMESH
      * \param z Z coordinate of new node
      * \return integer identifier of new node
      */
-    long AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
+    smIdType AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create a 0D element on the given node.
      *  \param IdOfNode Node IDs for creation of element.
      *  \param DuplicateElements to add one more 0D element to a node or not
      */
-    long Add0DElement(in long    IDOfNode,
-                      in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
+    smIdType Add0DElement(in smIdType    IDOfNode,
+                          in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create a ball element on the given node.
      *  \param IdOfNode Node IDs for creation of element.
      */
-    long AddBall(in long IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
+    smIdType AddBall(in smIdType IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create an edge, either linear and quadratic (this is determed
@@ -189,7 +190,7 @@ module SMESH
      *  of MED. This description is located by the following link:
      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
      */
-    long AddEdge(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
+    smIdType AddEdge(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create face, either linear and quadratic (this is determed
@@ -199,16 +200,16 @@ module SMESH
      *  of MED. This description is located by the following link:
      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
      */
-    long AddFace(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
+    smIdType AddFace(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 
-    long AddPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
+    smIdType AddPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
 
     /*!
      * Create a quadratic polygonal face
      *  \param IdsOfNodes - nodes of the polygon; corner nodes follow first
-     *  \return long - ID of a new polygon
+     *  \return smIdType- ID of a new polygon
      */
-    long AddQuadPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
+    smIdType AddQuadPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create volume, either linear and quadratic (this is determed
@@ -218,7 +219,7 @@ module SMESH
      *  of MED. This description is located by the following link:
      *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
      */
-    long AddVolume(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
+    smIdType AddVolume(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
 
     /*!
      *  Create volume of many faces, giving nodes for each face.
@@ -226,15 +227,15 @@ module SMESH
      *  \param Quantities List of integer values, Quantities[i]
      *         gives quantity of nodes in face number i.
      */
-    long AddPolyhedralVolume (in long_array IdsOfNodes,
-                              in long_array Quantities) raises (SALOME::SALOME_Exception);
+    smIdType AddPolyhedralVolume (in smIdType_array IdsOfNodes,
+                                  in long_array Quantities) raises (SALOME::SALOME_Exception);
     /*!
      *  Create volume of many faces, giving IDs of existing faces.
      *  \param IdsOfFaces List of face IDs for volume creation.
      *  \note The created volume will refer only to nodes
      *        of the given faces, not to the faces itself.
      */
-    long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces) raises (SALOME::SALOME_Exception);
+    smIdType AddPolyhedralVolumeByFaces (in smIdType_array IdsOfFaces) raises (SALOME::SALOME_Exception);
 
     /*!
      * Create 0D elements on all nodes of the given object.
@@ -255,7 +256,7 @@ module SMESH
       * \param NodeID - node ID
       * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
      */
-    void SetNodeOnVertex(in long NodeID, in long VertexID)
+    void SetNodeOnVertex(in smIdType NodeID, in long VertexID)
       raises (SALOME::SALOME_Exception);
     /*!
      * \brief Store node position on an edge
@@ -263,7 +264,7 @@ module SMESH
       * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
       * \param paramOnEdge - parameter on edge where the node is located
      */
-    void SetNodeOnEdge(in long NodeID, in long EdgeID, in double paramOnEdge)
+    void SetNodeOnEdge(in smIdType NodeID, in long EdgeID, in double paramOnEdge)
       raises (SALOME::SALOME_Exception);
     /*!
      * \brief Store node position on a face
@@ -272,34 +273,34 @@ module SMESH
       * \param u - U parameter on face where the node is located
       * \param v - V parameter on face where the node is located
      */
-    void SetNodeOnFace(in long NodeID, in long FaceID, in double u, in double v)
+    void SetNodeOnFace(in smIdType NodeID, in long FaceID, in double u, in double v)
       raises (SALOME::SALOME_Exception);
     /*!
      * \brief Bind a node to a solid
       * \param NodeID - node ID
       * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
      */
-    void SetNodeInVolume(in long NodeID, in long SolidID)
+    void SetNodeInVolume(in smIdType NodeID, in long SolidID)
       raises (SALOME::SALOME_Exception);
     /*!
      * \brief Bind an element to a shape
       * \param ElementID - element ID
       * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
      */
-    void SetMeshElementOnShape(in long ElementID, in long ShapeID)
+    void SetMeshElementOnShape(in smIdType ElementID, in long ShapeID)
       raises (SALOME::SALOME_Exception);
 
 
-    boolean MoveNode(in long NodeID, in double x, in double y, in double z)
+    boolean MoveNode(in smIdType NodeID, in double x, in double y, in double z)
       raises (SALOME::SALOME_Exception);
 
-    boolean InverseDiag(in long NodeID1, in long NodeID2) 
+    boolean InverseDiag(in smIdType NodeID1, in smIdType NodeID2) 
       raises (SALOME::SALOME_Exception);
 
-    boolean DeleteDiag(in long NodeID1, in long NodeID2) 
+    boolean DeleteDiag(in smIdType NodeID1, in smIdType NodeID2) 
       raises (SALOME::SALOME_Exception);
 
-    boolean Reorient(in long_array IDsOfElements) 
+    boolean Reorient(in smIdType_array IDsOfElements) 
       raises (SALOME::SALOME_Exception);
 
     boolean ReorientObject(in SMESH_IDSource theObject) 
@@ -337,7 +338,7 @@ module SMESH
      *                     is still performed; theMaxAngle is measured in radians.
      * \return \c true in case of success, FALSE otherwise.
      */
-    boolean TriToQuad (in long_array       IDsOfElements,
+    boolean TriToQuad (in smIdType_array   IDsOfElements,
                        in NumericalFunctor Criterion,
                        in double           MaxAngle) raises (SALOME::SALOME_Exception);
     /*!
@@ -355,7 +356,7 @@ module SMESH
      * \param theCriterion Is used to choose a diagonal for splitting.
      * \return TRUE in case of success, FALSE otherwise.
      */
-    boolean QuadToTri (in long_array       IDsOfElements,
+    boolean QuadToTri (in smIdType_array   IDsOfElements,
                        in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
     /*!
      * \brief Split quadrangles into triangles.
@@ -376,8 +377,8 @@ module SMESH
      * \param the13Diag Is used to choose a diagonal for splitting.
      * \return TRUE in case of success, FALSE otherwise.
      */
-    boolean SplitQuad (in long_array IDsOfElements,
-                       in boolean    Diag13) raises (SALOME::SALOME_Exception);
+    boolean SplitQuad (in smIdType_array IDsOfElements,
+                       in boolean        Diag13) raises (SALOME::SALOME_Exception);
     /*!
      * \brief Split quadrangles into triangles.
      *
@@ -393,7 +394,7 @@ module SMESH
      *  \return 1 if 1-3 diagonal is better, 2 if 2-4
      *          diagonal is better, 0 if error occurs.
      */
-    long BestSplit (in long             IDOfQuad,
+    long BestSplit (in long            IDOfQuad,
                     in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
 
     /*!
@@ -443,29 +444,29 @@ module SMESH
 
     enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
 
-    boolean Smooth(in long_array    IDsOfElements,
-                   in long_array    IDsOfFixedNodes,
-                   in long          MaxNbOfIterations,
-                   in double        MaxAspectRatio,
-                   in Smooth_Method Method) raises (SALOME::SALOME_Exception);
-
-    boolean SmoothObject(in SMESH_IDSource  theObject,
-                         in long_array      IDsOfFixedNodes,
-                         in long            MaxNbOfIterations,
-                         in double          MaxAspectRatio,
-                         in Smooth_Method   Method) raises (SALOME::SALOME_Exception);
-
-    boolean SmoothParametric(in long_array    IDsOfElements,
-                             in long_array    IDsOfFixedNodes,
-                             in long          MaxNbOfIterations,
-                             in double        MaxAspectRatio,
-                             in Smooth_Method Method) raises (SALOME::SALOME_Exception);
-
-    boolean SmoothParametricObject(in SMESH_IDSource  theObject,
-                                   in long_array      IDsOfFixedNodes,
-                                   in long            MaxNbOfIterations,
-                                   in double          MaxAspectRatio,
-                                   in Smooth_Method   Method) raises (SALOME::SALOME_Exception);
+    boolean Smooth(in smIdType_array IDsOfElements,
+                   in smIdType_array IDsOfFixedNodes,
+                   in short          MaxNbOfIterations,
+                   in double         MaxAspectRatio,
+                   in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
+
+    boolean SmoothObject(in SMESH_IDSource theObject,
+                         in smIdType_array IDsOfFixedNodes,
+                         in short          MaxNbOfIterations,
+                         in double         MaxAspectRatio,
+                         in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
+
+    boolean SmoothParametric(in smIdType_array IDsOfElements,
+                             in smIdType_array IDsOfFixedNodes,
+                             in short          MaxNbOfIterations,
+                             in double         MaxAspectRatio,
+                             in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
+
+    boolean SmoothParametricObject(in SMESH_IDSource theObject,
+                                   in smIdType_array IDsOfFixedNodes,
+                                   in short          MaxNbOfIterations,
+                                   in double         MaxAspectRatio,
+                                   in Smooth_Method  Method) raises (SALOME::SALOME_Exception);
 
     void ConvertToQuadratic(in boolean theForce3d) 
       raises (SALOME::SALOME_Exception);
@@ -561,12 +562,12 @@ module SMESH
      *         corresponding to groups the input elements included in.
      *  \return ListOfGroups - new groups created if \a ToMakeGroups is true
      */
-    ListOfGroups AdvancedExtrusion(in long_array IDsOfElements,
-                                   in DirStruct  StepVector,
-                                   in long       NbOfSteps,
-                                   in long       ExtrFlags,
-                                   in double     SewTolerance,
-                                   in boolean    ToMakeGroups)
+    ListOfGroups AdvancedExtrusion(in smIdType_array IDsOfElements,
+                                   in DirStruct      StepVector,
+                                   in long           NbOfSteps,
+                                   in long           ExtrFlags,
+                                   in double         SewTolerance,
+                                   in boolean        ToMakeGroups)
       raises (SALOME::SALOME_Exception);
 
     enum Extrusion_Error {
@@ -584,7 +585,7 @@ module SMESH
                                            in ListOfIDSources   Faces,
                                            in SMESH_IDSource    Path,
                                            in GEOM::GEOM_Object PathShape,
-                                           in long              NodeStart,
+                                           in smIdType          NodeStart,
                                            in boolean           HasAngles,
                                            in double_array      Angles,
                                            in boolean           AnglesVariation,
@@ -610,20 +611,20 @@ module SMESH
 
     enum MirrorType { POINT, AXIS, PLANE };
 
-    void Mirror (in long_array IDsOfElements,
-                 in AxisStruct Mirror,
-                 in MirrorType Type,
-                 in boolean    Copy) 
+    void Mirror (in smIdType_array IDsOfElements,
+                 in AxisStruct     Mirror,
+                 in MirrorType     Type,
+                 in boolean        Copy) 
       raises (SALOME::SALOME_Exception);
-    ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
-                                   in AxisStruct Mirror,
-                                   in MirrorType Type) 
+    ListOfGroups MirrorMakeGroups (in smIdType_array IDsOfElements,
+                                   in AxisStruct     Mirror,
+                                   in MirrorType     Type) 
       raises (SALOME::SALOME_Exception);
-    SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
-                               in AxisStruct Mirror,
-                               in MirrorType Type,
-                               in boolean    CopyGroups,
-                               in string     MeshName) 
+    SMESH_Mesh MirrorMakeMesh (in smIdType_array IDsOfElements,
+                               in AxisStruct     Mirror,
+                               in MirrorType     Type,
+                               in boolean        CopyGroups,
+                               in string         MeshName) 
       raises (SALOME::SALOME_Exception);
 
     void MirrorObject (in SMESH_IDSource theObject,
@@ -642,17 +643,17 @@ module SMESH
                                      in string         MeshName) 
       raises (SALOME::SALOME_Exception);
 
-    void Translate (in long_array IDsOfElements,
-                    in DirStruct  Vector,
-                    in boolean    Copy) 
+    void Translate (in smIdType_array IDsOfElements,
+                    in DirStruct      Vector,
+                    in boolean        Copy) 
       raises (SALOME::SALOME_Exception);
-    ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
-                                      in DirStruct  Vector) 
+    ListOfGroups TranslateMakeGroups (in smIdType_array IDsOfElements,
+                                      in DirStruct       Vector) 
       raises (SALOME::SALOME_Exception);
-    SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
-                                  in DirStruct  Vector,
-                                  in boolean    CopyGroups,
-                                  in string     MeshName) 
+    SMESH_Mesh TranslateMakeMesh (in smIdType_array IDsOfElements,
+                                  in DirStruct      Vector,
+                                  in boolean        CopyGroups,
+                                  in string         MeshName) 
       raises (SALOME::SALOME_Exception);
 
     void TranslateObject (in SMESH_IDSource theObject,
@@ -684,20 +685,20 @@ module SMESH
                               in string         MeshName) 
       raises (SALOME::SALOME_Exception);
 
-    void Rotate (in long_array IDsOfElements,
-                 in AxisStruct Axis,
-                 in double     AngleInRadians,
-                 in boolean    Copy) 
+    void Rotate (in smIdType_array IDsOfElements,
+                 in AxisStruct     Axis,
+                 in double         AngleInRadians,
+                 in boolean        Copy) 
       raises (SALOME::SALOME_Exception);
-    ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
-                                   in AxisStruct Axis,
-                                   in double     AngleInRadians) 
+    ListOfGroups RotateMakeGroups (in smIdType_array IDsOfElements,
+                                   in AxisStruct     Axis,
+                                   in double         AngleInRadians) 
       raises (SALOME::SALOME_Exception);
-    SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
-                               in AxisStruct Axis,
-                               in double     AngleInRadians,
-                               in boolean    CopyGroups,
-                               in string     MeshName)
+    SMESH_Mesh RotateMakeMesh (in smIdType_array IDsOfElements,
+                               in AxisStruct     Axis,
+                               in double         AngleInRadians,
+                               in boolean        CopyGroups,
+                               in string         MeshName)
       raises (SALOME::SALOME_Exception);
 
     void RotateObject (in SMESH_IDSource theObject,
@@ -775,13 +776,13 @@ module SMESH
      * If the given ID is a valid node ID (nodeID > 0), just move this node, else
      * move the node closest to the point to point's location and return ID of the node
      */
-    long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID) 
+    smIdType MoveClosestNodeToPoint(in double x, in double y, in double z, in smIdType nodeID) 
       raises (SALOME::SALOME_Exception);
 
     /*!
      * Return ID of node closest to a given point
      */
-    long FindNodeClosestTo(in double x, in double y, in double z) 
+    smIdType FindNodeClosestTo(in double x, in double y, in double z) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -789,7 +790,7 @@ module SMESH
      *
      * 'ALL' type means elements of any type excluding nodes and 0D elements
      */
-    long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type) 
+    smIdType_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -798,9 +799,9 @@ module SMESH
      *
      * 'ALL' type means elements of any type excluding nodes and 0D elements
      */
-    long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
-                                        in double x, in double y, in double z, 
-                                        in ElementType type) 
+    smIdType_array FindAmongElementsByPoint(in SMESH_IDSource elements,
+                                            in double x, in double y, in double z,
+                                            in ElementType type)
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -809,12 +810,12 @@ module SMESH
      * and coordinates of the projection point.
      * In the case if nothing found, return -1 and []
      */
-    long ProjectPoint(in double         x,
-                      in double         y,
-                      in double         z,
-                      in ElementType    type,
-                      in SMESH_IDSource meshObject,
-                      out double_array  projecton)
+    smIdType ProjectPoint(in double         x,
+                          in double         y,
+                          in double         z,
+                          in ElementType    type,
+                          in SMESH_IDSource meshObject,
+                          out double_array  projecton)
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -844,7 +845,7 @@ module SMESH
      *         If a group is closed, the first and last nodes of the group are same.
      */
     array_of_long_array Get1DBranches( in SMESH_IDSource       edges,
-                                       in long                 startNode,
+                                       in smIdType             startNode,
                                        out array_of_long_array nodeGroups)
       raises (SALOME::SALOME_Exception);
 
@@ -898,38 +899,38 @@ module SMESH
       SEW_INTERNAL_ERROR
     };
 
-    Sew_Error SewFreeBorders (in long FirstNodeID1,
-                              in long SecondNodeID1,
-                              in long LastNodeID1,
-                              in long FirstNodeID2,
-                              in long SecondNodeID2,
-                              in long LastNodeID2,
-                              in boolean CreatePolygons,
-                              in boolean CreatePolyedrs) 
+    Sew_Error SewFreeBorders (in smIdType FirstNodeID1,
+                              in smIdType SecondNodeID1,
+                              in smIdType LastNodeID1,
+                              in smIdType FirstNodeID2,
+                              in smIdType SecondNodeID2,
+                              in smIdType LastNodeID2,
+                              in boolean  CreatePolygons,
+                              in boolean  CreatePolyedrs) 
       raises (SALOME::SALOME_Exception);
 
-    Sew_Error SewConformFreeBorders (in long FirstNodeID1,
-                                     in long SecondNodeID1,
-                                     in long LastNodeID1,
-                                     in long FirstNodeID2,
-                                     in long SecondNodeID2) 
+    Sew_Error SewConformFreeBorders (in smIdType FirstNodeID1,
+                                     in smIdType SecondNodeID1,
+                                     in smIdType LastNodeID1,
+                                     in smIdType FirstNodeID2,
+                                     in smIdType SecondNodeID2) 
       raises (SALOME::SALOME_Exception);
 
-    Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
-                               in long SecondNodeIDOnFreeBorder,
-                               in long LastNodeIDOnFreeBorder,
-                               in long FirstNodeIDOnSide,
-                               in long LastNodeIDOnSide,
-                               in boolean CreatePolygons,
-                               in boolean CreatePolyedrs) 
+    Sew_Error SewBorderToSide (in smIdType FirstNodeIDOnFreeBorder,
+                               in smIdType SecondNodeIDOnFreeBorder,
+                               in smIdType LastNodeIDOnFreeBorder,
+                               in smIdType FirstNodeIDOnSide,
+                               in smIdType LastNodeIDOnSide,
+                               in boolean  CreatePolygons,
+                               in boolean  CreatePolyedrs) 
       raises (SALOME::SALOME_Exception);
 
-    Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
-                               in long_array IDsOfSide2Elements,
-                               in long       NodeID1OfSide1ToMerge,
-                               in long       NodeID1OfSide2ToMerge,
-                               in long       NodeID2OfSide1ToMerge,
-                               in long       NodeID2OfSide2ToMerge) 
+    Sew_Error SewSideElements (in smIdType_array IDsOfSide1Elements,
+                               in smIdType_array IDsOfSide2Elements,
+                               in smIdType       NodeID1OfSide1ToMerge,
+                               in smIdType       NodeID1OfSide2ToMerge,
+                               in smIdType       NodeID2OfSide1ToMerge,
+                               in smIdType       NodeID2OfSide2ToMerge) 
       raises (SALOME::SALOME_Exception);
 
    /*!
@@ -937,7 +938,7 @@ module SMESH
     * If number of nodes is not corresponded to type of
     * element - returns false
     */
-    boolean ChangeElemNodes(in long ide, in long_array newIDs) 
+    boolean ChangeElemNodes(in smIdType id, in smIdType_array newIDs) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -965,7 +966,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
      */
-    boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems ) 
+    boolean DoubleNodes( in smIdType_array theNodes, in smIdType_array theModifiedElems ) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -976,7 +977,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
      */
-    boolean DoubleNode( in long theNodeId, in long_array theModifiedElems ) 
+    boolean DoubleNode( in smIdType theNodeId, in smIdType_array theModifiedElems ) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -1037,9 +1038,9 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroup(), DoubleNodeGroups()
      */
-    boolean DoubleNodeElem( in long_array theElems,
-                            in long_array theNodesNot,
-                            in long_array theAffectedElems ) 
+    boolean DoubleNodeElem( in smIdType_array theElems,
+                            in smIdType_array theNodesNot,
+                            in smIdType_array theAffectedElems ) 
       raises (SALOME::SALOME_Exception);
 
     /*!
@@ -1053,8 +1054,8 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
      */
-    boolean DoubleNodeElemInRegion( in long_array theElems,
-                                    in long_array theNodesNot,
+    boolean DoubleNodeElemInRegion( in smIdType_array    theElems,
+                                    in smIdType_array    theNodesNot,
                                     in GEOM::GEOM_Object theShape ) 
       raises (SALOME::SALOME_Exception);
 
index dd76fd5..edd29d0 100644 (file)
@@ -29,6 +29,7 @@
 #define _SMESH_PATTERN_IDL_
 
 #include "SMESH_Mesh.idl"
+#include "SMESH_smIdType.idl"
 
 module SMESH
 {
@@ -85,10 +86,10 @@ module SMESH
      * the loaded pattern to mesh faces. The first key-point
      * will be mapped into <theNodeIndexOnKeyPoint1>-th node of each face
      */
-    point_array  ApplyToMeshFaces(in SMESH_Mesh theMesh,
-                                  in long_array theFacesIDs,
-                                  in long       theNodeIndexOnKeyPoint1,
-                                  in boolean    theReverse);
+    point_array  ApplyToMeshFaces(in SMESH_Mesh     theMesh,
+                                  in smIdType_array theFacesIDs,
+                                  in short          theNodeIndexOnKeyPoint1,
+                                  in boolean        theReverse);
 
     /*!
      * Compute nodes coordinates applying
@@ -97,10 +98,10 @@ module SMESH
      * The (0,0,1) key-point will be mapped into <theNode001Index>-th
      * node of each volume.
      */
-    point_array  ApplyToHexahedrons(in SMESH_Mesh theMesh,
-                                    in long_array theVolumesIDs,
-                                    in long       theNode000Index,
-                                    in long       theNode001Index);
+    point_array  ApplyToHexahedrons(in SMESH_Mesh     theMesh,
+                                    in smIdType_array theVolumesIDs,
+                                    in short          theNode000Index,
+                                    in short          theNode001Index);
 
     /*!
      * Create nodes and elements in <theMesh> using nodes
diff --git a/idl/SMESH_smIdType.idl.in b/idl/SMESH_smIdType.idl.in
new file mode 100644 (file)
index 0000000..5627249
--- /dev/null
@@ -0,0 +1,28 @@
+// Copyright (C) 2007-2020  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __SMESH_SMIDTYPE_IDL__
+#define __SMESH_SMIDTYPE_IDL__
+
+module SMESH
+{
+  typedef @SMESH_ID_TYPE@ smIdType;
+};
+
+#endif
\ No newline at end of file
index 1ef3a5f..1adabb5 100644 (file)
@@ -34,6 +34,7 @@
 #include "SMESHDS_Mesh.hxx"
 #include "SMESH_MeshAlgos.hxx"
 #include "SMESH_OctreeNode.hxx"
+#include "SMESH_Comment.hxx"
 
 #include <GEOMUtils.hxx>
 #include <Basics_Utils.hxx>
@@ -127,7 +128,7 @@ namespace {
     return aDist;
   }
 
-  int getNbMultiConnection( const SMDS_Mesh* theMesh, const int theId )
+  int getNbMultiConnection( const SMDS_Mesh* theMesh, const smIdType theId )
   {
     if ( theMesh == 0 )
       return 0;
@@ -225,7 +226,7 @@ void NumericalFunctor::SetMesh( const SMDS_Mesh* theMesh )
   myMesh = theMesh;
 }
 
-bool NumericalFunctor::GetPoints(const int       theId,
+bool NumericalFunctor::GetPoints(const smIdType       theId,
                                  TSequenceOfXYZ& theRes ) const
 {
   theRes.clear();
@@ -322,12 +323,12 @@ bool NumericalFunctor::IsApplicable( long theElementId ) const
  */
 //================================================================================
 
-void NumericalFunctor::GetHistogram(int                     nbIntervals,
-                                    std::vector<int>&       nbEvents,
-                                    std::vector<double>&    funValues,
-                                    const std::vector<int>& elements,
-                                    const double*           minmax,
-                                    const bool              isLogarithmic)
+void NumericalFunctor::GetHistogram(int                          nbIntervals,
+                                    std::vector<int>&            nbEvents,
+                                    std::vector<double>&         funValues,
+                                    const std::vector<smIdType>& elements,
+                                    const double*                minmax,
+                                    const bool                   isLogarithmic)
 {
   if ( nbIntervals < 1 ||
        !myMesh ||
@@ -346,7 +347,7 @@ void NumericalFunctor::GetHistogram(int                     nbIntervals,
   }
   else
   {
-    std::vector<int>::const_iterator id = elements.begin();
+    std::vector<smIdType>::const_iterator id = elements.begin();
     for ( ; id != elements.end(); ++id )
       values.insert( GetValue( *id ));
   }
@@ -1971,7 +1972,7 @@ void Length2D::GetValues(TValues& theValues)
       {
         // use special nodes iterator
         SMDS_NodeIteratorPtr anIter = anElem->interlacedNodesIterator();
-        long aNodeId[4] = { 0,0,0,0 };
+        smIdType aNodeId[4] = { 0,0,0,0 };
         gp_Pnt P[4];
 
         double aLength = 0;
@@ -2008,7 +2009,7 @@ void Length2D::GetValues(TValues& theValues)
       }
       else {
         SMDS_NodeIteratorPtr aNodesIter = anElem->nodeIterator();
-        long aNodeId[2] = {0,0};
+        smIdType aNodeId[2] = {0,0};
         gp_Pnt P[3];
 
         double aLength;
@@ -2023,7 +2024,7 @@ void Length2D::GetValues(TValues& theValues)
         for( ; aNodesIter->more(); )
         {
           aNode = aNodesIter->next();
-          long anId = aNode->GetID();
+          smIdType anId = aNode->GetID();
 
           P[2] = SMESH_NodeXYZ( aNode );
 
@@ -2192,7 +2193,7 @@ double MultiConnection2D::GetValue( long theElementId )
       if (!anIter) break;
 
       const SMDS_MeshNode *aNode, *aNode0 = 0;
-      TColStd_MapOfInteger aMap, aMapPrev;
+      NCollection_Map< smIdType, smIdHasher > aMap, aMapPrev;
 
       for (i = 0; i <= len; i++) {
         aMapPrev = aMap;
@@ -2214,7 +2215,7 @@ double MultiConnection2D::GetValue( long theElementId )
         while (anElemIter->more()) {
           const SMDS_MeshElement* anElem = anElemIter->next();
           if (anElem != 0 && anElem->GetType() == SMDSAbs_Face) {
-            int anId = anElem->GetID();
+            smIdType anId = anElem->GetID();
 
             aMap.Add(anId);
             if (aMapPrev.Contains(anId)) {
@@ -2675,14 +2676,14 @@ void FreeEdges::SetMesh( const SMDS_Mesh* theMesh )
   myMesh = theMesh;
 }
 
-bool FreeEdges::IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId  )
+bool FreeEdges::IsFreeEdge( const SMDS_MeshNode** theNodes, const smIdType theFaceId  )
 {
   SMDS_ElemIteratorPtr anElemIter = theNodes[ 0 ]->GetInverseElementIterator(SMDSAbs_Face);
   while( anElemIter->more() )
   {
     if ( const SMDS_MeshElement* anElem = anElemIter->next())
     {
-      const int anId = anElem->GetID();
+      const smIdType anId = anElem->GetID();
       if ( anId != theFaceId && anElem->GetNodeIndex( theNodes[1] ) >= 0 )
         return false;
     }
@@ -2967,8 +2968,8 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
     SMDSAbs_ElementType aGrpElType = (SMDSAbs_ElementType)aGrp->GetType();
     if ( myType == aGrpElType || (myType == SMDSAbs_All && aGrpElType != SMDSAbs_Node) ) {
       // add elements IDS into control
-      int aSize = aGrp->Extent();
-      for (int i = 0; i < aSize; i++)
+      smIdType aSize = aGrp->Extent();
+      for (smIdType i = 0; i < aSize; i++)
         myIDs.insert( aGrp->GetID(i+1) );
     }
   }
@@ -3119,7 +3120,7 @@ ConnectedElements::ConnectedElements():
 SMDSAbs_ElementType ConnectedElements::GetType() const
 { return myType; }
 
-int ConnectedElements::GetNode() const
+smIdType ConnectedElements::GetNode() const
 { return myXYZ.empty() ? myNodeID : 0; } // myNodeID can be found by myXYZ
 
 std::vector<double> ConnectedElements::GetPoint() const
@@ -3146,7 +3147,7 @@ void ConnectedElements::SetMesh( const SMDS_Mesh* theMesh )
   }
 }
 
-void ConnectedElements::SetNode( int nodeID )
+void ConnectedElements::SetNode( smIdType nodeID )
 {
   myNodeID = nodeID;
   myXYZ.clear();
@@ -3206,7 +3207,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
       return false;
 
     std::list< const SMDS_MeshNode* > nodeQueue( 1, node0 );
-    std::set< int > checkedNodeIDs;
+    std::set< smIdType > checkedNodeIDs;
     // algo:
     // foreach node in nodeQueue:
     //   foreach element sharing a node:
@@ -3231,7 +3232,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
         while ( nIt->more() )
         {
           const SMDS_MeshNode* n = static_cast< const SMDS_MeshNode* >( nIt->next() );
-          if ( checkedNodeIDs.insert( n->GetID() ).second )
+          if ( checkedNodeIDs.insert( n->GetID()).second )
             nodeQueue.push_back( n );
         }
       }
@@ -3378,56 +3379,56 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
 {
   theResStr.Clear();
 
-  TColStd_SequenceOfInteger     anIntSeq;
-  TColStd_SequenceOfAsciiString aStrSeq;
+  TIDsSeq                             anIntSeq;
+  NCollection_Sequence< std::string > aStrSeq;
 
-  TColStd_MapIteratorOfMapOfInteger anIter( myIds );
+  TIDsMap::Iterator anIter( myIds );
   for ( ; anIter.More(); anIter.Next() )
   {
-    int anId = anIter.Key();
-    TCollection_AsciiString aStr( anId );
+    smIdType anId = anIter.Key();
+    SMESH_Comment aStr( anId );
     anIntSeq.Append( anId );
     aStrSeq.Append( aStr );
   }
 
-  for ( int i = 1, n = myMin.Length(); i <= n; i++ )
+  for ( smIdType i = 1, n = myMin.size(); i <= n; i++ )
   {
-    int aMinId = myMin( i );
-    int aMaxId = myMax( i );
+    smIdType aMinId = myMin[i];
+    smIdType aMaxId = myMax[i];
 
-    TCollection_AsciiString aStr;
+    SMESH_Comment aStr;
     if ( aMinId != IntegerFirst() )
-      aStr += aMinId;
+      aStr << aMinId;
 
-    aStr += "-";
+    aStr << "-";
 
-    if ( aMaxId != IntegerLast() )
-      aStr += aMaxId;
+    if ( aMaxId != std::numeric_limits<smIdType>::max() )
+      aStr << aMaxId;
 
     // find position of the string in result sequence and insert string in it
     if ( anIntSeq.Length() == 0 )
     {
       anIntSeq.Append( aMinId );
-      aStrSeq.Append( aStr );
+      aStrSeq.Append( (const char*)aStr );
     }
     else
     {
       if ( aMinId < anIntSeq.First() )
       {
         anIntSeq.Prepend( aMinId );
-        aStrSeq.Prepend( aStr );
+        aStrSeq.Prepend( (const char*)aStr );
       }
       else if ( aMinId > anIntSeq.Last() )
       {
         anIntSeq.Append( aMinId );
-        aStrSeq.Append( aStr );
+        aStrSeq.Append( (const char*)aStr );
       }
       else
         for ( int j = 1, k = anIntSeq.Length(); j <= k; j++ )
           if ( aMinId < anIntSeq( j ) )
           {
             anIntSeq.InsertBefore( j, aMinId );
-            aStrSeq.InsertBefore( j, aStr );
+            aStrSeq.InsertBefore( j, (const char*)aStr );
             break;
           }
     }
@@ -3435,13 +3436,14 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
 
   if ( aStrSeq.Length() == 0 )
     return;
-
-  theResStr = aStrSeq( 1 );
+  std::string aResStr;
+  aResStr = aStrSeq( 1 );
   for ( int j = 2, k = aStrSeq.Length(); j <= k; j++  )
   {
-    theResStr += ",";
-    theResStr += aStrSeq( j );
+    aResStr += ",";
+    aResStr += aStrSeq( j );
   }
+  theResStr = aResStr.c_str();
 }
 
 //=======================================================================
@@ -3451,8 +3453,8 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
 //=======================================================================
 bool RangeOfIds::SetRangeStr( const TCollection_AsciiString& theStr )
 {
-  myMin.Clear();
-  myMax.Clear();
+  myMin.clear();
+  myMax.clear();
   myIds.Clear();
 
   TCollection_AsciiString aStr = theStr;
@@ -3490,8 +3492,8 @@ bool RangeOfIds::SetRangeStr( const TCollection_AsciiString& theStr )
            (!aMaxStr.IsEmpty() && !aMaxStr.IsIntegerValue()) )
         return false;
 
-      myMin.Append( aMinStr.IsEmpty() ? IntegerFirst() : aMinStr.IntegerValue() );
-      myMax.Append( aMaxStr.IsEmpty() ? IntegerLast()  : aMaxStr.IntegerValue() );
+      myMin.push_back( aMinStr.IsEmpty() ? IntegerFirst() : aMinStr.IntegerValue() );
+      myMax.push_back( aMaxStr.IsEmpty() ? IntegerLast()  : aMaxStr.IntegerValue() );
     }
   }
 
@@ -3540,8 +3542,8 @@ bool RangeOfIds::IsSatisfy( long theId )
   if ( myIds.Contains( theId ) )
     return true;
 
-  for ( int i = 1, n = myMin.Length(); i <= n; i++ )
-    if ( theId >= myMin( i ) && theId <= myMax( i ) )
+  for ( size_t i = 0; i < myMin.size(); i++ )
+    if ( theId >= myMin[i] && theId <= myMax[i] )
       return true;
 
   return false;
@@ -3917,7 +3919,7 @@ bool ManifoldPart::process()
 
   // the map of non manifold links and bad geometry
   TMapOfLink aMapOfNonManifold;
-  TColStd_MapOfInteger aMapOfTreated;
+  TIDsMap    aMapOfTreated;
 
   // begin cycle on faces from start index and run on vector till the end
   //  and from begin to start index to cover whole vector
@@ -3930,18 +3932,18 @@ bool ManifoldPart::process()
     // as result next time when fi will be equal to aStartIndx
 
     SMDS_MeshFace* aFacePtr = myAllFacePtr[ fi ];
-    if ( aMapOfTreated.Contains( aFacePtr->GetID() ) )
+    if ( aMapOfTreated.Contains( aFacePtr->GetID()) )
       continue;
 
     aMapOfTreated.Add( aFacePtr->GetID() );
-    TColStd_MapOfInteger aResFaces;
+    TIDsMap aResFaces;
     if ( !findConnected( myAllFacePtrIntDMap, aFacePtr,
                          aMapOfNonManifold, aResFaces ) )
       continue;
-    TColStd_MapIteratorOfMapOfInteger anItr( aResFaces );
+    TIDsMap::Iterator anItr( aResFaces );
     for ( ; anItr.More(); anItr.Next() )
     {
-      int aFaceId = anItr.Key();
+      smIdType aFaceId = anItr.Key();
       aMapOfTreated.Add( aFaceId );
       myMapIds.Add( aFaceId );
     }
@@ -3977,7 +3979,7 @@ bool ManifoldPart::findConnected
                  ( const ManifoldPart::TDataMapFacePtrInt& theAllFacePtrInt,
                   SMDS_MeshFace*                           theStartFace,
                   ManifoldPart::TMapOfLink&                theNonManifold,
-                  TColStd_MapOfInteger&                    theResFaces )
+                  TIDsMap&                                 theResFaces )
 {
   theResFaces.Clear();
   if ( !theAllFacePtrInt.size() )
@@ -4045,7 +4047,7 @@ bool ManifoldPart::findConnected
         SMDS_MeshFace* aNextFace = *pFace;
         if ( aPrevFace == aNextFace )
           continue;
-        int anNextFaceID = aNextFace->GetID();
+        smIdType anNextFaceID = aNextFace->GetID();
         if ( myIsOnlyManifold && theResFaces.Contains( anNextFaceID ) )
          // should not be with non manifold restriction. probably bad topology
           continue;
@@ -4276,7 +4278,9 @@ void ElementsOnSurface::process()
   if ( !myMeshModifTracer.GetMesh() )
     return;
 
-  myIds.ReSize( myMeshModifTracer.GetMesh()->GetMeshInfo().NbElements( myType ));
+  int nbElems = FromSmIdType<int>( myMeshModifTracer.GetMesh()->GetMeshInfo().NbElements( myType ));
+  if ( nbElems > 0 )
+    myIds.ReSize( nbElems );
 
   SMDS_ElemIteratorPtr anIter = myMeshModifTracer.GetMesh()->elementsIterator( myType );
   for(; anIter->more(); )
index 4fa988d..1ce5f4d 100644 (file)
@@ -32,8 +32,8 @@
 #include <GeomAPI_ProjectPointOnSurf.hxx>
 #include <Quantity_Color.hxx>
 #include <TColStd_MapOfInteger.hxx>
-#include <TColStd_SequenceOfInteger.hxx>
 #include <TCollection_AsciiString.hxx>
+#include <NCollection_Map.hxx>
 #include <TopAbs.hxx>
 #include <TopoDS_Face.hxx>
 #include <gp_XYZ.hxx>
@@ -58,6 +58,9 @@ class ShapeAnalysis_Surface;
 class gp_Pln;
 class gp_Pnt;
 
+typedef NCollection_Map< smIdType, smIdHasher > TIDsMap;
+typedef NCollection_Sequence<smIdType> TIDsSeq;
+
 namespace SMESH{
   namespace Controls{
 
@@ -130,12 +133,12 @@ namespace SMESH{
       virtual void SetMesh( const SMDS_Mesh* theMesh );
       virtual double GetValue( long theElementId );
       virtual double GetValue(const TSequenceOfXYZ& /*thePoints*/) { return -1.0;};
-      void GetHistogram(int                     nbIntervals,
-                        std::vector<int>&       nbEvents,
-                        std::vector<double>&    funValues,
-                        const std::vector<int>& elements,
-                        const double*           minmax=0,
-                        const bool              isLogarithmic = false);
+      void GetHistogram(int                          nbIntervals,
+                        std::vector<int>&            nbEvents,
+                        std::vector<double>&         funValues,
+                        const std::vector<smIdType>& elements,
+                        const double*                minmax=0,
+                        const bool                   isLogarithmic = false);
       bool IsApplicable( long theElementId ) const;
       virtual bool IsApplicable( const SMDS_MeshElement* element ) const;
       virtual SMDSAbs_ElementType GetType() const = 0;
@@ -144,7 +147,7 @@ namespace SMESH{
       void  SetPrecision( const long thePrecision );
       double Round( const double & value );
       
-      bool GetPoints(const int theId, TSequenceOfXYZ& theRes) const;
+      bool GetPoints(const smIdType theId, TSequenceOfXYZ& theRes) const;
       static bool GetPoints(const SMDS_MeshElement* theElem, TSequenceOfXYZ& theRes);
     protected:
       const SMDS_Mesh*        myMesh;
@@ -423,9 +426,9 @@ namespace SMESH{
       double GetTolerance () const { return myToler; }
 
     private:
-      double               myToler;
-      TColStd_MapOfInteger myCoincidentIDs;
-      TMeshModifTracer     myMeshModifTracer;
+      double           myToler;
+      TIDsMap          myCoincidentIDs;
+      TMeshModifTracer myMeshModifTracer;
     };
     typedef boost::shared_ptr<CoincidentNodes> CoincidentNodesPtr;
    
@@ -591,7 +594,7 @@ namespace SMESH{
       virtual void SetMesh( const SMDS_Mesh* theMesh );
       virtual bool IsSatisfy( long theElementId );
       virtual SMDSAbs_ElementType GetType() const;
-      static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId  );
+      static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const smIdType theFaceId  );
       typedef long TElemId;
       struct Border{
         TElemId myElemId;
@@ -650,9 +653,9 @@ namespace SMESH{
     protected:
       const SMDS_Mesh*              myMesh;
 
-      TColStd_SequenceOfInteger     myMin;
-      TColStd_SequenceOfInteger     myMax;
-      TColStd_MapOfInteger          myIds;
+      std::vector< smIdType >       myMin;
+      std::vector< smIdType >       myMax;
+      TIDsMap                       myIds;
 
       SMDSAbs_ElementType           myType;
     };
@@ -833,7 +836,7 @@ namespace SMESH{
       bool    findConnected( const TDataMapFacePtrInt& theAllFacePtrInt,
                              SMDS_MeshFace*            theStartFace,
                              TMapOfLink&               theNonManifold,
-                             TColStd_MapOfInteger&     theResFaces );
+                             TIDsMap&                  theResFaces );
       bool    isInPlane( const SMDS_MeshFace* theFace1,
                           const SMDS_MeshFace* theFace2 );
       void    expandBoundary( TMapOfLink&            theMapOfBoundary,
@@ -847,8 +850,8 @@ namespace SMESH{
 
     private:
       const SMDS_Mesh*      myMesh;
-      TColStd_MapOfInteger  myMapIds;
-      TColStd_MapOfInteger  myMapBadGeomIds;
+      TIDsMap               myMapIds;
+      TIDsMap               myMapBadGeomIds;
       TVectorOfFacePtr      myAllFacePtr;
       TDataMapFacePtrInt    myAllFacePtrIntDMap;
       double                myAngToler;
@@ -909,7 +912,7 @@ namespace SMESH{
 
     private:
       TMeshModifTracer      myMeshModifTracer;
-      TColStd_MapOfInteger  myIds;
+      TIDsMap               myIds;
       SMDSAbs_ElementType   myType;
       TopoDS_Face           mySurf;
       double                myToler;
@@ -1149,7 +1152,7 @@ namespace SMESH{
       TMeshModifTracer     myMeshModifTracer;
       long                 myFaceID;
       double               myToler;
-      TColStd_MapOfInteger myCoplanarIDs;
+      TIDsMap              myCoplanarIDs;
     };
     typedef boost::shared_ptr<CoplanarFaces> CoplanarFacesPtr;
 
@@ -1162,9 +1165,9 @@ namespace SMESH{
     public:
       ConnectedElements();
       //virtual Predicate*   clone() const { return new ConnectedElements( *this ); }
-      void                 SetNode( int nodeID );
+      void                 SetNode( smIdType nodeID );
       void                 SetPoint( double x, double y, double z );
-      int                  GetNode() const;
+      smIdType             GetNode() const;
       std::vector<double>  GetPoint() const;
 
       void                 SetType( SMDSAbs_ElementType theType );
@@ -1176,14 +1179,14 @@ namespace SMESH{
       //const std::set<long>& GetDomainIDs() const { return myOkIDs; }
 
     private:
-      int                 myNodeID;
+      smIdType            myNodeID;
       std::vector<double> myXYZ;
       SMDSAbs_ElementType myType;
       TMeshModifTracer    myMeshModifTracer;
 
       void                clearOkIDs();
       bool                myOkIDsReady;
-      std::set< int >     myOkIDs; // empty means that there is one domain
+      std::set<smIdType>  myOkIDs; // empty means that there is one domain
     };
     typedef boost::shared_ptr<ConnectedElements> ConnectedElementsPtr;
 
index a1ad1d2..a1af526 100644 (file)
@@ -28,6 +28,7 @@
 #define _INCLUDE_DRIVER_MESH
 
 #include "SMESH_ComputeError.hxx"
+#include "SMDS_Mesh.hxx"
 
 #include <string>
 #include <vector>
@@ -50,12 +51,13 @@ class MESHDRIVER_EXPORT Driver_Mesh
 
   enum Status {
     DRS_OK,
-    DRS_EMPTY,          // a file contains no mesh with the given name
-    DRS_WARN_RENUMBER,  // a file has overlapped ranges of element numbers,
-                        // so the numbers from the file are ignored
-    DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
+    DRS_EMPTY,           // a file contains no mesh with the given name
+    DRS_WARN_RENUMBER,   // a file has overlapped ranges of element numbers,
+                         // so the numbers from the file are ignored
+    DRS_WARN_SKIP_ELEM,  // some elements were skipped due to incorrect file data
     DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
-    DRS_FAIL            // general failure (exception etc.)
+    DRS_FAIL,            // general failure (exception etc.)
+    DRS_TOO_LARGE_MESH   // mesh is too large for export
   };
 
   void                SetMeshId(int theMeshId);
@@ -70,6 +72,22 @@ class MESHDRIVER_EXPORT Driver_Mesh
 
   virtual SMESH_ComputeErrorPtr GetError();
 
+  //virtual bool CanExportMesh() const { return false; } //= 0;
+
+  // check if a mesh is too large to export it using IDTYPE;
+  // check either max ID or number of elements
+  template< typename IDTYPE >
+    static bool IsMeshTooLarge( const SMDS_Mesh* mesh, bool checkIDs )
+  {
+    if ( sizeof( IDTYPE ) < sizeof( smIdType ))
+    {
+      const smIdType maxNB = std::numeric_limits< IDTYPE >::max();
+      return (( checkIDs ? mesh->MaxNodeID()    : mesh->NbNodes() )  > maxNB ||
+              ( checkIDs ? mesh->MaxElementID() : mesh->NbElements() > maxNB ));
+    }
+    return false;
+  }
+
  protected:
   std::string myFile;
   std::string myMeshName;
index 9f1f212..86aae72 100644 (file)
@@ -33,6 +33,8 @@
 #include "SMESH_Comment.hxx"
 #include "SMESH_TypeDefs.hxx"
 
+#include <smIdType.hxx>
+
 #include <gp_XYZ.hxx>
 
 #include <cgnslib.h>
@@ -59,9 +61,9 @@ namespace
   struct TZoneData
   {
     int                    _id;
-    int                    _nodeIdShift; // nb nodes in previously read zones
-    int                    _elemIdShift; // nb faces in previously read zones
-    int                    _nbNodes, _nbElems;
+    smIdType               _nodeIdShift; // nb nodes in previously read zones
+    smIdType               _elemIdShift; // nb faces in previously read zones
+    smIdType               _nbNodes, _nbElems;
     int                    _meshDim;
     int                    _sizeX, _sizeY, _sizeZ, _nbCells; // structured
     cgsize_t               _sizes[NB_ZONE_SIZE_VAL];
@@ -550,10 +552,10 @@ namespace
     nbNodes = ids[0];
     ++ids;
 #endif
-    vector<int> idVec( nbNodes );
-    for ( int i = 0; i < nbNodes; ++i )
-      idVec[ i ] = (int) ids[ i ];
-    return mesh->AddPolygonalFaceWithID( idVec, ID );
+    vector<smIdType> idVec( ids[0] );
+    for ( int i = 0; i < ids[0]; ++i )
+      idVec[ i ] = ToSmIdType( ids[ i + 1]);
+    return mesh->AddPolygonalFaceWithID( idVec, ToSmIdType(ID) );
   }
 
   typedef SMDS_MeshElement* (* PAddElemFun) (cgsize_t* ids, SMESHDS_Mesh* mesh, int ID);
@@ -1172,7 +1174,7 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
             case 2: addElemFun = & add_QUAD_4; break;
             case 3: addElemFun = & add_HEXA_8; break;
             }
-            int elemID = meshInfo.NbElements();
+            smIdType elemID = meshInfo.NbElements();
             const SMDS_MeshElement* elem = 0;
             for ( size_t i = 0; i < ids.size(); i += nbElemNodes )
             {
index b4d3dfe..9320b82 100644 (file)
@@ -201,17 +201,17 @@ namespace
    */
   struct TPolyhedFace
   {
-    int _id; // id of NGON_n
-    vector< int > _nodes; // lowest node IDs used for sorting
+    smIdType _id; // id of NGON_n
+    vector< smIdType > _nodes; // lowest node IDs used for sorting
 
-    TPolyhedFace( const SMDS_MeshNode** nodes, const int nbNodes, int ID):_id(ID)
+    TPolyhedFace( const SMDS_MeshNode** nodes, const smIdType nbNodes, smIdType ID):_id(ID)
     {
-      set< int > ids;
-      for ( int i = 0; i < nbNodes; ++i )
+      set< smIdType > ids;
+      for ( smIdType i = 0; i < nbNodes; ++i )
         ids.insert( nodes[i]->GetID() );
 
       _nodes.resize( 3 ); // std::min( nbNodes, 4 )); hope 3 nodes is enough
-      set< int >::iterator idIt = ids.begin();
+      set< smIdType >::iterator idIt = ids.begin();
       for ( size_t j = 0; j < _nodes.size(); ++j, ++idIt )
         _nodes[j] = *idIt;
     }
@@ -267,6 +267,9 @@ Driver_Mesh::Status DriverCGNS_Write::Perform()
   if ( !myMesh || myMesh->GetMeshInfo().NbElements() < 1 )
     return addMessage( !myMesh ? "NULL mesh" : "Empty mesh (no elements)", /*fatal = */true );
 
+  if ( Driver_Mesh::IsMeshTooLarge< cgsize_t >( myMesh, /*checkIDs =*/ false))
+    return DRS_TOO_LARGE_MESH;
+
   // open the file
   if ( cg_open(myFile.c_str(), CG_MODE_MODIFY, &_fn) != CG_OK &&
        cg_open(myFile.c_str(), CG_MODE_WRITE,  &_fn) != CG_OK )
@@ -295,13 +298,15 @@ Driver_Mesh::Status DriverCGNS_Write::Perform()
   // create a Zone
   // --------------
 
-  int nbCells = myMesh->NbEdges();
+  smIdType nbCells = myMesh->NbEdges();
   if ( meshDim == 3 )
     nbCells = myMesh->NbVolumes();
   else if ( meshDim == 2 )
     nbCells = myMesh->NbFaces();
 
-  cgsize_t size[9] = { myMesh->NbNodes(), nbCells, /*NBoundVertex=*/0, 0,0,0,0,0,0 };
+  cgsize_t size[9] = { FromSmIdType<cgsize_t>( myMesh->NbNodes() ),
+                       FromSmIdType<cgsize_t>( nbCells ),
+                       /*NBoundVertex=*/0, 0,0,0,0,0,0 };
   int iZone;
   if ( cg_zone_write( _fn, iBase, "SMESH_Mesh", size,
                       CGNS_ENUMV( Unstructured ), &iZone) != CG_OK )
index 7a34b27..27fa48b 100644 (file)
@@ -76,7 +76,7 @@ Driver_Mesh::Status DriverDAT_R_SMDS_Mesh::Perform()
     myMesh->AddNodeWithID(coordX, coordY, coordZ, intNumPoint);
   }
   
-  fprintf(stdout, "%d noeuds\n", myMesh->NbNodes());
+  fprintf(stdout, "%ld noeuds\n", myMesh->NbNodes());
   /****************************************************************************
    *                       LECTURE DES ELEMENTS                                *
    ****************************************************************************/
index f4399a7..2eb69bd 100644 (file)
@@ -37,7 +37,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
   Kernel_Utils::Localizer loc;
   Status aResult = DRS_OK;
 
-  int nbNodes, nbCells;
+  smIdType nbNodes, nbCells;
 #if defined(WIN32) && defined(UNICODE)
   std::wstring file2Read = Kernel_Utils::utf8_decode_s(myFile);
   FILE* aFileId = _wfopen(file2Read.c_str(), L"w+");
@@ -60,7 +60,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
   nbNodes = myMesh->NbNodes();
 
   /* Combien de mailles, faces ou aretes ? */
-  int nb_of_edges, nb_of_faces, nb_of_volumes;
+  smIdType nb_of_edges, nb_of_faces, nb_of_volumes;
   nb_of_edges = myMesh->NbEdges();
   nb_of_faces = myMesh->NbFaces();
   nb_of_volumes = myMesh->NbVolumes();
@@ -70,7 +70,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
   SCRUTE(nb_of_volumes);
 
   //fprintf(stdout, "%d %d\n", nbNodes, nbCells);
-  fprintf(aFileId, "%d %d\n", nbNodes, nbCells);
+  fprintf(aFileId, "%ld %ld\n", nbNodes, nbCells);
 
   /****************************************************************************
    *                       ECRITURE DES NOEUDS                                 *
@@ -104,10 +104,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
 
     for ( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
     {
-      int nodeID = it->next()->GetID();
+      smIdType nodeID = it->next()->GetID();
       if ( !nodeNumByID.empty() )
         nodeID = nodeNumByID[ nodeID ];
-      fprintf(aFileId, "%d ", nodeID );
+      fprintf(aFileId, "%ld ", nodeID );
     }
     fprintf(aFileId, "\n");
   }
@@ -120,10 +120,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
 
     for( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
     {
-      int nodeID = it->next()->GetID();
+      smIdType nodeID = it->next()->GetID();
       if ( !nodeNumByID.empty() )
         nodeID = nodeNumByID[ nodeID ];
-      fprintf(aFileId, "%d ", nodeID );
+      fprintf(aFileId, "%ld ", nodeID );
     }
     fprintf(aFileId, "\n");
   }
@@ -155,10 +155,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
 
     for( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
     {
-      int nodeID = it->next()->GetID();
+      smIdType nodeID = it->next()->GetID();
       if ( !nodeNumByID.empty() )
         nodeID = nodeNumByID[ nodeID ];
-      fprintf(aFileId, "%d ", nodeID );
+      fprintf(aFileId, "%ld ", nodeID );
     }
 
     fprintf(aFileId, "\n");
index 187abbc..175d810 100644 (file)
@@ -89,7 +89,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
 
   int ref;
 
-  const int nodeIDShift = myMesh->GetMeshInfo().NbNodes();
+  const smIdType nodeIDShift = myMesh->GetMeshInfo().NbNodes();
   if ( version != GmfFloat )
   {
     double x, y, z;
@@ -114,7 +114,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
 
   /* Read edges */
-  const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType edgeIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
   {
     // read extra vertices for quadratic edges
@@ -150,7 +150,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read triangles */
-  const int triaIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType triaIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
   {
     // read extra vertices for quadratic triangles
@@ -194,7 +194,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read quadrangles */
-  const int quadIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType quadIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
   {
     // read extra vertices for quadratic quadrangles
@@ -248,7 +248,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read terahedra */
-  const int tetIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType tetIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
   {
     // read extra vertices for quadratic tetrahedra
@@ -273,14 +273,14 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
     for ( int i = 1; i <= nbTet; ++i )
     {
       GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
-      std::vector<int>& midN = quadNodesAtTetrahedra[ i ];  
+      std::vector<int>& midN = quadNodesAtTetrahedra[ i ];
       if ( midN.size() >= 10-4 ) // TETRA10
       {
-        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], 
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3],
                                        midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
                                        tetIDShift + i ))
           status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10,
-                                    iN[0], iN[2], iN[1], iN[3], 
+                                    iN[0], iN[2], iN[1], iN[3],
                                     midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
       }
       else // TETRA4
@@ -293,7 +293,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read pyramids */
-  const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType pyrIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbPyr = GmfStatKwd(meshID, GmfPyramids))
   {
     GmfGotoKwd(meshID, GmfPyramids);
@@ -306,7 +306,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read hexahedra */
-  const int hexIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType hexIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
   {
     // read extra vertices for quadratic hexahedra
@@ -321,7 +321,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
                   &iN[6], &iN[7], &iN[8], &iN[9],
                   &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
                   &iN[14],
-                  &iN[15], &iN[16], &iN[17], &iN[18], 
+                  &iN[15], &iN[16], &iN[17], &iN[18],
                   &iN[19],
                   &iN[20]);                          // HEXA27
         if ( iN[0] <= nbHex )
@@ -347,7 +347,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
                                        midN[7], midN[6], midN[5], midN[4],
                                        midN[8], midN[11], midN[10], midN[9],
                                        hexIDShift + i ))
-          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20,
                                     iN[0], iN[3], iN[2], iN[1],
                                     iN[4], iN[7], iN[6], iN[5],
                                     midN[3], midN[2], midN[1], midN[0],
@@ -366,7 +366,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
                                        midN[17],
                                        midN[18],
                                        hexIDShift + i ))
-          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27,
                                     iN[0], iN[3], iN[2], iN[1],
                                     iN[4], iN[7], iN[6], iN[5],
                                     midN[3], midN[2], midN[1], midN[0],
@@ -389,7 +389,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   }
 
   /* Read prism */
-  const int prismIDShift = myMesh->GetMeshInfo().NbElements();
+  const smIdType prismIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbPrism = GmfStatKwd(meshID, GmfPrisms))
   {
     GmfGotoKwd(meshID, GmfPrisms);
@@ -405,33 +405,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   // Read some entities into groups
   // see MeshGems/Docs/meshgems_formats_description.pdf
 
-    // get ids of existing groups
-    std::set< int > groupIDs;
-    const std::set<SMESHDS_GroupBase*>&          groups = myMesh->GetGroups();
-    std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
-    for ( ; grIter != groups.end(); ++grIter )
-      groupIDs.insert( (*grIter)->GetID() );
-    if ( groupIDs.empty() ) groupIDs.insert( 0 );
+  // get ids of existing groups
+  std::set< int > groupIDs;
+  const std::set<SMESHDS_GroupBase*>&          groups = myMesh->GetGroups();
+  std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
+  for ( ; grIter != groups.end(); ++grIter )
+    groupIDs.insert( (*grIter)->GetID() );
+  if ( groupIDs.empty() ) groupIDs.insert( 0 );
 
   // Read required entities into groups
   if ( _makeRequiredGroups )
   {
 
-    const int kes[4][3] = { { GmfRequiredVertices,      SMDSAbs_Node, nodeIDShift },
-                            { GmfRequiredEdges,         SMDSAbs_Edge, edgeIDShift },
-                            { GmfRequiredTriangles,     SMDSAbs_Face, triaIDShift },
-                            { GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }
-                          };
+    const smIdType kes[4][3] = { { GmfRequiredVertices,      SMDSAbs_Node, nodeIDShift },
+                                 { GmfRequiredEdges,         SMDSAbs_Edge, edgeIDShift },
+                                 { GmfRequiredTriangles,     SMDSAbs_Face, triaIDShift },
+                                 { GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }
+    };
     const char* names[4] = { "_required_Vertices"      ,
                              "_required_Edges"         ,
                              "_required_Triangles"     ,
-                             "_required_Quadrilaterals" 
-                           };
+                             "_required_Quadrilaterals"
+    };
     for ( int i = 0; i < 4; ++i )
     {
-      int                 gmfKwd = kes[i][0];
+      int                 gmfKwd = FromSmIdType<int>( kes[i][0] );
       SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
-      int                 shift  = kes[i][2];
+      smIdType            shift  = kes[i][2];
       if ( int nb = GmfStatKwd(meshID, gmfKwd))
       {
         const int newID = *groupIDs.rbegin() + 1;
@@ -454,27 +454,27 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   if ( _makeFaultGroups )
   {
 
-    const int kes[7][3] = { { GmfFault_SmallTri,     SMDSAbs_Face, triaIDShift },
-                            { GmfFault_BadShape,     SMDSAbs_Face, triaIDShift },
-                            { GmfFault_Overlap,      SMDSAbs_Face, triaIDShift },
-                            { GmfFault_Inter,        SMDSAbs_Face, triaIDShift },
-                            { GmfFault_NearTri,      SMDSAbs_Face, triaIDShift },
-                            { GmfFault_FreeEdge,     SMDSAbs_Face, triaIDShift },
-                            { GmfFault_MultipleEdge, SMDSAbs_Face, triaIDShift }
-                          };
+    const smIdType kes[7][3] = { { GmfFault_SmallTri,     SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_BadShape,     SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_Overlap,      SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_Inter,        SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_NearTri,      SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_FreeEdge,     SMDSAbs_Face, triaIDShift },
+                                 { GmfFault_MultipleEdge, SMDSAbs_Face, triaIDShift }
+    };
     const char* names[7] = { "Fault_SmallTri",
                              "Fault_BadShape",
                              "Fault_Overlap",
-                             "Fault_Inter", 
+                             "Fault_Inter",
                              "Fault_NearTri",
                              "Fault_FreeEdge",
                              "Fault_MultipleEdge"
-                           };
+    };
     for ( int i = 0; i < 7; ++i )
     {
-      int                 gmfKwd = kes[i][0];
+      int                 gmfKwd = FromSmIdType<int>( kes[i][0] );
       SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
-      int                 shift  = kes[i][2];
+      smIdType            shift  = kes[i][2];
       if ( int nb = GmfStatKwd(meshID, gmfKwd))
       {
         const int newID = *groupIDs.rbegin() + 1;
index 48874c2..dfa9ca5 100644 (file)
@@ -57,8 +57,8 @@ extern "C"
   elemIt = elementIterator( SMDSGeom );                                 \
   if ( elemIt->more() )                                                 \
   {                                                                     \
-  int totalNbElems  = myMesh->GetMeshInfo().NbElements( SMDSGeom );     \
-  int nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType );      \
+  smIdType totalNbElems  = myMesh->GetMeshInfo().NbElements( SMDSGeom );\
+  smIdType nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType ); \
   if ( totalNbElems - nbLinearElems > 0 )                               \
   {                                                                     \
   GmfSetKwd(meshID, GmfKwd, totalNbElems - nbLinearElems);              \
@@ -100,6 +100,9 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
 {
   Kernel_Utils::Localizer loc;
 
+  if ( Driver_Mesh::IsMeshTooLarge< int >( myMesh, /*checkIDs =*/ false))
+    return DRS_TOO_LARGE_MESH;
+
   const int dim = 3, version = sizeof(double) < 8 ? 1 : 2;
 
   int meshID = GmfOpenMesh( myFile.c_str(), GmfWrite, version, dim );
@@ -115,7 +118,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
 
   // nodes
   std::map< const SMDS_MeshNode* , int > node2IdMap;
-  int iN = 0, nbNodes = myMesh->NbNodes();
+  smIdType iN = 0, nbNodes = myMesh->NbNodes();
   GmfSetKwd( meshID, GmfVertices, nbNodes );
   double xyz[3];
   SMDS_NodeIteratorPtr nodeIt = myMesh->nodesIterator();
index d804edc..1a3fd08 100644 (file)
@@ -36,6 +36,7 @@
 #include "MED_Utilities.hxx"
 
 #include <NCollection_Map.hxx>
+#include <smIdType.hxx>
 
 #include "utilities.h"
 
@@ -225,7 +226,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
 
       // Reading pre information about all MED cells
       //--------------------------------------------
-      typedef MED::TVector<int> TNodeIds;
+      typedef MED::TVector<smIdType> TNodeIds;
       bool takeNumbers = true;  // initially we trust the numbers from file
       MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo, eNOD);
       MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
@@ -269,7 +270,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
               aNodeIds.assign( aBallInfo->myConn->begin(), aBallInfo->myConn->end());
 
             // allocate array of diameters
-            vtkIdType maxID = myMesh->MaxElementID() + aNbBalls;
+            vtkIdType maxID = FromSmIdType<vtkIdType>(myMesh->MaxElementID() + aNbBalls);
             if ( anIsElemNum && !aBallInfo->myElemNum->empty() )
               maxID = *std::max_element( aBallInfo->myElemNum->begin(),
                                          aBallInfo->myElemNum->end() );
@@ -318,7 +319,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
             EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX;
 
             typedef SMDS_MeshFace* (SMESHDS_Mesh::* FAddPolyWithID)
-              (const std::vector<int> & nodes_ids, const int ID);
+              (const std::vector<smIdType> & nodes_ids, const smIdType ID);
             typedef SMDS_MeshFace* (SMESHDS_Mesh::* FAddPolygon)
               (const std::vector<const SMDS_MeshNode*> & nodes);
 
@@ -355,7 +356,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
 #endif
                 if ( anIsElemNum ) {
                   TInt anElemId = aPolygoneInfo->GetElemNum( iElem );
-                  anElement = (myMesh->*addPolyWithID)( aNodeIds, anElemId );
+                  anElement = (myMesh->*addPolyWithID)( aNodeIds, ToSmIdType(anElemId) );
                 }
                 if ( !anElement ) {
                   aNodes.resize( aNbConn );
@@ -436,7 +437,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
 #endif
                 if(anIsElemNum){
                   TInt anElemId = aPolyedreInfo->GetElemNum(iElem);
-                  anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,anElemId);
+                  anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,ToSmIdType(anElemId));
                 }
                 if(!anElement){
                   vector<const SMDS_MeshNode*> aNodes(aNbNodes);
index a0304a5..041d1e8 100644 (file)
@@ -90,7 +90,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh *      mesh,
   }
 
   // find out "MED order" of elements - sort elements by geom type
-  int nbElems;
+  smIdType nbElems;
   if ( _nbElemsByGeom.empty() || _elemType != type )
   {
     _elemType = type;
index 326409f..e7739b1 100644 (file)
@@ -246,7 +246,7 @@ namespace
     const SMDS_MeshNode* GetNode(){
       return myCurrentNode;
     }
-    MED::TIntVector::value_type GetID(){
+    MED::TIDVector::value_type GetID(){
       return myCurrentNode->GetID();
     }
     MED::TFloatVector::value_type GetCoord(TInt theCoodId){
@@ -343,12 +343,21 @@ namespace
   }
 }
 
+//================================================================================
+/*!
+ * \brief Write my mesh
+ */
+//================================================================================
+
 Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 {
   Status aResult = DRS_OK;
   try {
     //MESSAGE("Perform - myFile : "<<myFile);
 
+    if ( Driver_Mesh::IsMeshTooLarge< TInt >( myMesh, /*checkIDs =*/ true ))
+      return DRS_TOO_LARGE_MESH;
+
     // Creating the MED mesh for corresponding SMDS structure
     //-------------------------------------------------------
     string aMeshName;
@@ -475,12 +484,12 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     int myEdgesDefaultFamilyId      = 0;
     int myFacesDefaultFamilyId      = 0;
     int myVolumesDefaultFamilyId    = 0;
-    int nbNodes      = myMesh->NbNodes();
-    int nb0DElements = myMesh->Nb0DElements();
-    int nbBalls      = myMesh->NbBalls();
-    int nbEdges      = myMesh->NbEdges();
-    int nbFaces      = myMesh->NbFaces();
-    int nbVolumes    = myMesh->NbVolumes();
+    smIdType nbNodes      = myMesh->NbNodes();
+    smIdType nb0DElements = myMesh->Nb0DElements();
+    smIdType nbBalls      = myMesh->NbBalls();
+    smIdType nbEdges      = myMesh->NbEdges();
+    smIdType nbFaces      = myMesh->NbFaces();
+    smIdType nbVolumes    = myMesh->NbVolumes();
     if (myDoGroupOfNodes)   myNodesDefaultFamilyId      = REST_NODES_FAMILY;
     if (myDoGroupOfEdges)   myEdgesDefaultFamilyId      = REST_EDGES_FAMILY;
     if (myDoGroupOfFaces)   myFacesDefaultFamilyId      = REST_FACES_FAMILY;
@@ -539,7 +548,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
     const EBooleen      theIsElemNames = eFAUX;
     const EConnectivite theConnMode    = eNOD;
 
-    TInt aNbNodes = myMesh->NbNodes();
+    TInt aNbNodes = FromSmIdType<TInt>( myMesh->NbNodes() );
     PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo, aNbNodes,
                                             theMode, theSystem, theIsElemNum, theIsElemNames);
 
@@ -559,7 +568,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
         aTCoordSlice[2] = 0.;
 
       // node number
-      int aNodeID = aCoordHelperPtr->GetID();
+      TInt aNodeID = FromSmIdType<TInt>( aCoordHelperPtr->GetID() );
       aNodeInfo->SetElemNum( iNode, aNodeID );
 #ifdef _EDF_NODE_IDS_
       aNodeIdMap.insert( aNodeIdMap.end(), make_pair( aNodeID, iNode+1 ));
@@ -625,66 +634,66 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 #endif
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eBALL,
-                                             nbElemInfo.NbBalls(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbBalls()),
                                              SMDSAbs_Ball));
 #ifdef _ELEMENTS_BY_DIM_
     anEntity = eARETE;
 #endif
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eSEG2,
-                                             nbElemInfo.NbEdges( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbEdges( ORDER_LINEAR )),
                                              SMDSAbs_Edge));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eSEG3,
-                                             nbElemInfo.NbEdges( ORDER_QUADRATIC ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbEdges( ORDER_QUADRATIC )),
                                              SMDSAbs_Edge));
 #ifdef _ELEMENTS_BY_DIM_
     anEntity = eFACE;
 #endif
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eTRIA3,
-                                             nbElemInfo.NbTriangles( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbTriangles( ORDER_LINEAR )),
                                              SMDSAbs_Face));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eTRIA6,
-                                             nbElemInfo.NbTriangles( ORDER_QUADRATIC ) -
-                                             nbElemInfo.NbBiQuadTriangles(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbTriangles( ORDER_QUADRATIC ) -
+                                             nbElemInfo.NbBiQuadTriangles()),
                                              SMDSAbs_Face));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eTRIA7,
-                                             nbElemInfo.NbBiQuadTriangles(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbBiQuadTriangles()),
                                              SMDSAbs_Face));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eQUAD4,
-                                             nbElemInfo.NbQuadrangles( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbQuadrangles( ORDER_LINEAR )),
                                              SMDSAbs_Face));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eQUAD8,
-                                             nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ) -
-                                             nbElemInfo.NbBiQuadQuadrangles(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ) -
+                                             nbElemInfo.NbBiQuadQuadrangles()),
                                              SMDSAbs_Face));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eQUAD9,
-                                             nbElemInfo.NbBiQuadQuadrangles(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbBiQuadQuadrangles()),
                                              SMDSAbs_Face));
     if ( polyTypesSupported ) {
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYGONE,
-                                               nbElemInfo.NbPolygons( ORDER_LINEAR ),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_LINEAR )),
                                                SMDSAbs_Face));
       // we need one more loop on poly elements to count nb of their nodes
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYGONE,
-                                               nbElemInfo.NbPolygons( ORDER_LINEAR ),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_LINEAR )),
                                                SMDSAbs_Face));
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYGON2,
-                                               nbElemInfo.NbPolygons( ORDER_QUADRATIC ),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_QUADRATIC )),
                                                SMDSAbs_Face));
       // we need one more loop on QUAD poly elements to count nb of their nodes
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYGON2,
-                                               nbElemInfo.NbPolygons( ORDER_QUADRATIC ),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_QUADRATIC )),
                                                SMDSAbs_Face));
     }
 #ifdef _ELEMENTS_BY_DIM_
@@ -692,58 +701,58 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
 #endif
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eTETRA4,
-                                             nbElemInfo.NbTetras( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbTetras( ORDER_LINEAR )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eTETRA10,
-                                             nbElemInfo.NbTetras( ORDER_QUADRATIC ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbTetras( ORDER_QUADRATIC )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              ePYRA5,
-                                             nbElemInfo.NbPyramids( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbPyramids( ORDER_LINEAR )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              ePYRA13,
-                                             nbElemInfo.NbPyramids( ORDER_QUADRATIC ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbPyramids( ORDER_QUADRATIC )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              ePENTA6,
-                                             nbElemInfo.NbPrisms( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbPrisms( ORDER_LINEAR )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              ePENTA15,
-                                             nbElemInfo.NbQuadPrisms(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbQuadPrisms()),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              ePENTA18,
-                                             nbElemInfo.NbBiQuadPrisms(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbBiQuadPrisms()),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eHEXA8,
-                                             nbElemInfo.NbHexas( ORDER_LINEAR ),
+                                             FromSmIdType<TInt>(nbElemInfo.NbHexas( ORDER_LINEAR )),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eHEXA20,
-                                             nbElemInfo.NbHexas( ORDER_QUADRATIC )-
-                                             nbElemInfo.NbTriQuadHexas(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbHexas( ORDER_QUADRATIC )-
+                                             nbElemInfo.NbTriQuadHexas()),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eHEXA27,
-                                             nbElemInfo.NbTriQuadHexas(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbTriQuadHexas()),
                                              SMDSAbs_Volume));
     aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                              eOCTA12,
-                                             nbElemInfo.NbHexPrisms(),
+                                             FromSmIdType<TInt>(nbElemInfo.NbHexPrisms()),
                                              SMDSAbs_Volume));
     if ( polyTypesSupported ) {
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYEDRE,
-                                               nbElemInfo.NbPolyhedrons(),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolyhedrons()),
                                                SMDSAbs_Volume));
       // we need one more loop on poly elements to count nb of their nodes
       aTElemTypeDatas.push_back( TElemTypeData(anEntity,
                                                ePOLYEDRE,
-                                               nbElemInfo.NbPolyhedrons(),
+                                               FromSmIdType<TInt>(nbElemInfo.NbPolyhedrons()),
                                                SMDSAbs_Volume));
     }
 
@@ -822,13 +831,13 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
             for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
               const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
 #ifdef _EDF_NODE_IDS_
-              aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
+              aTConnSlice[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
 #else
               aTConnSlice[ iNode ] = aNode->GetID();
 #endif
             }
             // element number
-            aPolygoneInfo->SetElemNum( iElem, anElem->GetID() );
+            aPolygoneInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
 
             // family number
             int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
@@ -896,14 +905,14 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
             while ( nodeIt->more() ) {
               const SMDS_MeshElement* aNode = nodeIt->next();
 #ifdef _EDF_NODE_IDS_
-              conn[ iNode ] = aNodeIdMap[aNode->GetID()];
+              conn[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
 #else
               conn[ iNode ] = aNode->GetID();
 #endif
               ++iNode;
             }
             // element number
-            aPolyhInfo->SetElemNum( iElem, anElem->GetID() );
+            aPolyhInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
 
             // family number
             int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
@@ -930,12 +939,12 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
           // connectivity
           const SMDS_MeshElement* aNode = anElem->GetNode( 0 );
 #ifdef _EDF_NODE_IDS_
-          (*aBallInfo->myConn)[ iElem ] = aNodeIdMap[aNode->GetID()];
+          (*aBallInfo->myConn)[ iElem ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
 #else
           (*aBallInfo->myConn)[ iElem ] = aNode->GetID();
 #endif
           // element number
-          aBallInfo->SetElemNum( iElem, anElem->GetID() );
+          aBallInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
 
           // diameter
           aBallInfo->myDiameters[ iElem ] =
@@ -978,13 +987,13 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
           for (TInt iNode = 0; iNode < aNbNodes; iNode++) {
             const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
 #ifdef _EDF_NODE_IDS_
-            aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
+            aTConnSlice[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
 #else
             aTConnSlice[ iNode ] = aNode->GetID();
 #endif
           }
           // element number
-          aCellInfo->SetElemNum( iElem, anElem->GetID() );
+          aCellInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
 
           // family number
           int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
index cee15c2..2263c15 100644 (file)
@@ -45,6 +45,10 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
 {
   Kernel_Utils::Localizer loc;
   Status aResult = DRS_OK;
+
+  if ( Driver_Mesh::IsMeshTooLarge< int >( myMesh, /*checkIDs =*/ false))
+    return DRS_TOO_LARGE_MESH;
+
 #if defined(WIN32) && defined(UNICODE)
   std::wstring aFile = Kernel_Utils::utf8_decode_s(myFile);
   std::ofstream out_stream(aFile.c_str());
@@ -113,7 +117,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
           {
             const SMDS_MeshNode* aNode = aNodesIter->next();
             if ( nodeLabelByID.empty() )
-              aRec.node_labels.push_back( aNode->GetID() );
+              aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
             else
               aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
           }
@@ -137,7 +141,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
           for ( aRec.node_labels.clear(); aNodesIter->more();  ) {
             const SMDS_MeshNode* aNode = aNodesIter->next();
             if ( nodeLabelByID.empty() )
-              aRec.node_labels.push_back( aNode->GetID() );
+              aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
             else
               aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
           }
@@ -195,7 +199,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
           {
             const SMDS_MeshElement* aNode = aNodesIter->next();
             if ( nodeLabelByID.empty() )
-              aRec.node_labels.push_back( aNode->GetID() );
+              aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
             else
               aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
           }
@@ -226,7 +230,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
             while ( aIter->more() ) {
               const SMDS_MeshElement* aNode = aIter->next();
               if ( nodeLabelByID.empty() )
-                aRec.NodeList.push_back( aNode->GetID() );
+                aRec.NodeList.push_back( FromSmIdType<int>(aNode->GetID()) );
               else
                 aRec.NodeList.push_back( nodeLabelByID[ aNode->GetID() ]);
             }
@@ -236,7 +240,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
             while ( aIter->more() ) {
               const SMDS_MeshElement* aElem = aIter->next();
               if ( elemLabelByID.empty() )
-                aRec.ElementList.push_back( aElem->GetID() );
+                aRec.ElementList.push_back( FromSmIdType<int>(aElem->GetID()) );
               else
                 aRec.ElementList.push_back( elemLabelByID[ aElem->GetID() ]);
             }
@@ -256,11 +260,11 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
       EXCEPTION(runtime_error,"ERROR: Output file not good.");
   }
   catch(const std::exception& exc){
-    INFOS("Follow exception was cought:\n\t"<<exc.what());
+    INFOS("Follow exception was caught:\n\t"<<exc.what());
     throw;
   }
   catch(...){
-    INFOS("Unknown exception was cought !!!");
+    INFOS("Unknown exception was caught !!!");
     throw;
   }
   return aResult;
index 54d4ba1..00ecb02 100644 (file)
@@ -35,7 +35,8 @@ typedef std::list<SMESHDS_GroupBase*> TGroupList;
 class MESHDRIVERUNV_EXPORT DriverUNV_W_SMDS_Mesh: public Driver_SMDS_Mesh
 {
  public:
-  virtual Status Perform();
+
+  virtual Status Perform() override;
 
   void AddGroup(SMESHDS_GroupBase* theGroup) { myGroups.push_back(theGroup); }
 
index 69fa7f3..e5c3380 100644 (file)
@@ -32,6 +32,7 @@
 #include <map>
 
 #include <med.h>
+#include <smIdType.hxx>
 
 #ifdef WIN32
 #pragma warning(disable:4099)
@@ -77,6 +78,7 @@ namespace MED
   typedef enum {eCOOR, eCONN, eNOM, eNUM, eFAM, eCOOR_IND1, eCOOR_IND2, eCOOR_IND3} ETable;
 
   typedef TVector<TInt> TIntVector;
+  typedef TVector<smIdType> TIDVector;
   typedef TVector<TFloat> TFloatVector;
   typedef TVector<std::string> TStringVector;
   typedef std::set<std::string> TStringSet;
index 2e22d2c..5c64804 100644 (file)
@@ -139,8 +139,8 @@ SMESH_ActorDef::SMESH_ActorDef()
 
   myIsFacesOriented = false;
 
-  int controlsIncrement = SMESH_ActorProps::props()->controlsIncrement();
-  int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
+  float  controlsIncrement = (float) SMESH_ActorProps::props()->controlsIncrement();
+  float selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
 
   myControlsPrecision = -1;
   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@@ -148,11 +148,11 @@ SMESH_ActorDef::SMESH_ActorDef()
   if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
     myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
 
-  double aElem0DSize    = SMESH::GetFloat("SMESH:elem0d_size",5);
-  double aBallElemSize  = SMESH::GetFloat("SMESH:ball_elem_size",10);
-  double aBallElemScale = SMESH::GetFloat("SMESH:ball_elem_scale",1.0);
-  double aLineWidth     = SMESH::GetFloat("SMESH:element_width",1);
-  double aOutlineWidth  = SMESH::GetFloat("SMESH:outline_width",1);
+  float aElem0DSize    = (float) SMESH::GetFloat("SMESH:elem0d_size",5);
+  float aBallElemSize  = (float) SMESH::GetFloat("SMESH:ball_elem_size",10);
+  float aBallElemScale = (float) SMESH::GetFloat("SMESH:ball_elem_scale",1.0);
+  float aLineWidth     = (float) SMESH::GetFloat("SMESH:element_width",1);
+  float aOutlineWidth  = (float) SMESH::GetFloat("SMESH:outline_width",1);
 
   SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
   bool aBoldNd    = true;
@@ -1035,7 +1035,7 @@ void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
       return;
     }
 
-    int aNbCells = myFunctor ? myVisualObj->GetNbEntities( myFunctor->GetType() ) : 0;
+    smIdType aNbCells = myFunctor ? myVisualObj->GetNbEntities( myFunctor->GetType() ) : 0;
     bool aShowOnlyScalarBarTitle = false;
     if(aNbCells) {
       //myControlMode = theMode;
@@ -1135,7 +1135,7 @@ void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
   //Update();
 }
 
-int SMESH_ActorDef::GetNumberControlEntities()
+smIdType SMESH_ActorDef::GetNumberControlEntities()
 {
   SMESH_DeviceActor* anAct = NULL;
   switch(myControlMode){
@@ -1161,7 +1161,7 @@ int SMESH_ActorDef::GetNumberControlEntities()
       break;
     default:;
   }
-  return (anAct) ? anAct->GetUnstructuredGrid()->GetNumberOfCells() : -1;
+  return anAct ? anAct->GetUnstructuredGrid()->GetNumberOfCells() : -1;
 }
 
 void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer)
@@ -1453,27 +1453,27 @@ void SMESH_ActorDef::UnShrink()
 }
 
 
-int SMESH_ActorDef::GetNodeObjId(int theVtkID)
+vtkIdType SMESH_ActorDef::GetNodeObjId(vtkIdType theVtkID)
 {
   return myPickableActor->GetNodeObjId(theVtkID);
 }
 
-double* SMESH_ActorDef::GetNodeCoord(int theObjID)
+double* SMESH_ActorDef::GetNodeCoord(vtkIdType theObjID)
 {
   return myPickableActor->GetNodeCoord(theObjID);
 }
 
-int SMESH_ActorDef::GetNodeVtkId(int theObjID)
+vtkIdType SMESH_ActorDef::GetNodeVtkId(vtkIdType theObjID)
 {
   return myPickableActor->GetNodeVtkId(theObjID);
 }
 
-int SMESH_ActorDef::GetElemObjId(int theVtkID)
+vtkIdType SMESH_ActorDef::GetElemObjId(vtkIdType theVtkID)
 {
   return myPickableActor->GetElemObjId(theVtkID);
 }
 
-vtkCell* SMESH_ActorDef::GetElemCell(int theObjID)
+vtkCell* SMESH_ActorDef::GetElemCell(vtkIdType theObjID)
 {
   return myPickableActor->GetElemCell(theObjID);
 }
@@ -1665,11 +1665,11 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
 
 void SMESH_ActorDef::SetRepresentation (int theMode)
 {
-  int aNbEdges   = myVisualObj->GetNbEntities(SMDSAbs_Edge);
-  int aNbFaces   = myVisualObj->GetNbEntities(SMDSAbs_Face);
-  int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
-  int aNb0Ds     = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
-  int aNbBalls   = myVisualObj->GetNbEntities(SMDSAbs_Ball);
+  smIdType aNbEdges   = myVisualObj->GetNbEntities(SMDSAbs_Edge);
+  smIdType aNbFaces   = myVisualObj->GetNbEntities(SMDSAbs_Face);
+  smIdType aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
+  smIdType aNb0Ds     = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
+  smIdType aNbBalls   = myVisualObj->GetNbEntities(SMDSAbs_Ball);
 
   if ( myRepresentationCache && aNbEdges + aNbFaces + aNbVolumes + aNb0Ds + aNbBalls )
   {
@@ -1714,7 +1714,7 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
   myPickableActor = myBaseActor;
   vtkProperty *aProp = NULL, *aBackProp = NULL;
   vtkProperty *aPropVN = NULL, *aPropVR = NULL;
-  SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
+  SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::eNoneRepr;
   SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
   switch (myRepresentation) {
   case ePoint:
@@ -2126,8 +2126,8 @@ void SMESH_ActorDef::UpdateSelectionProps()
 {
   QColor selectionColor = SMESH_ActorProps::props()->selectionColor();
   QColor highlightColor = SMESH_ActorProps::props()->highlightColor();
-  int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
-  double width = GetLineWidth();
+  float  selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
+  float  width = (float) GetLineWidth();
   myHighlightProp->SetColor(selectionColor.redF(), selectionColor.greenF(), selectionColor.blueF());
   myHighlightProp->SetLineWidth(width + selectionIncrement);
   myPreselectProp->SetColor(highlightColor.redF(), highlightColor.greenF(), highlightColor.blueF());
@@ -2143,17 +2143,17 @@ double SMESH_ActorDef::GetLineWidth()
 
 void SMESH_ActorDef::SetLineWidth(double theVal)
 {
-  int controlsIncrement = SMESH_ActorProps::props()->controlsIncrement();
-  int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
+  float  controlsIncrement = (float) SMESH_ActorProps::props()->controlsIncrement();
+  float selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
 
-  myEdgeProp->SetLineWidth(theVal);
+  myEdgeProp->SetLineWidth((float) theVal);
 
-  my1DProp->SetLineWidth(theVal + controlsIncrement);
-  my1DExtProp->SetLineWidth(theVal + controlsIncrement);
-  my2DExtProp->SetLineWidth(theVal + controlsIncrement);
-  my3DExtProp->SetLineWidth(theVal + controlsIncrement);
-  myHighlightProp->SetLineWidth(theVal + selectionIncrement);
-  myPreselectProp->SetLineWidth(theVal + selectionIncrement);
+  my1DProp       ->SetLineWidth((float) theVal + controlsIncrement);
+  my1DExtProp    ->SetLineWidth((float) theVal + controlsIncrement);
+  my2DExtProp    ->SetLineWidth((float) theVal + controlsIncrement);
+  my3DExtProp    ->SetLineWidth((float) theVal + controlsIncrement);
+  myHighlightProp->SetLineWidth((float) theVal + selectionIncrement);
+  myPreselectProp->SetLineWidth((float) theVal + selectionIncrement);
   Modified();
 }
 
@@ -2164,21 +2164,21 @@ double SMESH_ActorDef::GetOutlineWidth()
 
 void SMESH_ActorDef::SetOutlineWidth(double theVal)
 {
-  myOutLineProp->SetLineWidth(theVal);
+  myOutLineProp->SetLineWidth((float) theVal);
   Modified();
 }
 
 void SMESH_ActorDef::Set0DSize(double theVal)
 {
-  my0DProp->SetPointSize(theVal);
-  myHighlightProp->SetPointSize(theVal);
-  myPreselectProp->SetPointSize(theVal);
+  my0DProp       ->SetPointSize((float) theVal);
+  myHighlightProp->SetPointSize((float) theVal);
+  myPreselectProp->SetPointSize((float) theVal);
 
   if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
-    aCustom->Set0DSize(theVal);
+    aCustom->Set0DSize((float) theVal);
   }
   if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
-    aCustom->Set0DSize(theVal);
+    aCustom->Set0DSize((float) theVal);
   }
 
   Modified();
@@ -2191,13 +2191,13 @@ double SMESH_ActorDef::Get0DSize()
 
 void SMESH_ActorDef::SetBallSize(double theVal)
 {
-  myBallProp->SetPointSize(theVal);
+  myBallProp->SetPointSize((float) theVal);
 
   if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
-    aCustom->SetBallSize(theVal);
+    aCustom->SetBallSize((float) theVal);
   }
   if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
-    aCustom->SetBallSize(theVal);
+    aCustom->SetBallSize((float) theVal);
   }
 
   Modified();
@@ -2226,7 +2226,7 @@ void SMESH_ActorDef::SetBallScale( double theVal )
   Modified();
 }
 
-int SMESH_ActorDef::GetObjDimension( const int theObjId )
+int SMESH_ActorDef::GetObjDimension( const vtkIdType theObjId )
 {
   return myVisualObj->GetElemDimension( theObjId );
 }
@@ -2496,7 +2496,7 @@ void SMESH_ActorDef::UpdateDistribution()
     SMESH_VisualObjDef::TEntityList elems;
     if ( dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get()))
       dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
-    std::vector<int> elemIds; elemIds.reserve( elems.size() );
+    std::vector<smIdType> elemIds; elemIds.reserve( elems.size() );
     for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
       elemIds.push_back( (*e)->GetID());
     vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
@@ -2682,7 +2682,7 @@ SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram()
     SMESH_VisualObjDef::TEntityList elems;
     if ( dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get()))
       dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
-    std::vector<int> elemIds;
+    std::vector<smIdType> elemIds;
 
     for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
       elemIds.push_back( (*e)->GetID());
index ba533c5..6de50af 100644 (file)
@@ -148,7 +148,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
   virtual void SetControl(SMESH::Controls::FunctorPtr) = 0;
   virtual eControl GetControlMode() = 0;
   virtual SMESH::Controls::FunctorPtr GetFunctor() = 0;
-  virtual int GetNumberControlEntities() = 0;
+  virtual smIdType GetNumberControlEntities() = 0;
 
   virtual SMESH_ScalarBarActor* GetScalarBarActor() = 0;
 
index 259e13a..0d3051c 100644 (file)
@@ -144,14 +144,14 @@ class SMESH_ActorDef : public SMESH_Actor
   virtual void SetBallScale(double size);
   virtual double GetBallScale();
 
-  virtual int GetNodeObjId(int theVtkID);
-  virtual double* GetNodeCoord(int theObjID);
-  virtual int GetNodeVtkId(int theObjID);
+  virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
+  virtual double* GetNodeCoord(vtkIdType theObjID);
+  virtual vtkIdType GetNodeVtkId(vtkIdType theObjID);
 
-  virtual int GetElemObjId(int theVtkID);
-  virtual vtkCell* GetElemCell(int theObjID);
+  virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
+  virtual vtkCell* GetElemCell(vtkIdType theObjID);
 
-  virtual int GetObjDimension( const int theObjId );
+  virtual int GetObjDimension( const vtkIdType theObjId ) override;
 
   virtual void SetVisibility(int theMode);
   void SetVisibility(int theMode, bool theIsUpdateRepersentation);
@@ -206,7 +206,7 @@ class SMESH_ActorDef : public SMESH_Actor
 
   virtual void SetControlMode(eControl theMode);
   virtual void SetControl(SMESH::Controls::FunctorPtr theFunctor);
-  virtual int GetNumberControlEntities();
+  virtual smIdType GetNumberControlEntities();
   virtual eControl GetControlMode(){ return myControlMode;}
   virtual SMESH::Controls::FunctorPtr GetFunctor() { return myFunctor; }
 
index e6a39f1..f79f01a 100644 (file)
@@ -157,17 +157,17 @@ namespace SMESH
     }
   }
 
-  std::map<SMDSAbs_ElementType,int> GetEntitiesFromObject(SMESH_VisualObj *theObject) {
-    std::map<SMDSAbs_ElementType,int> entities;
-    entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_0DElement,
+  std::map<SMDSAbs_ElementType,smIdType> GetEntitiesFromObject(SMESH_VisualObj *theObject) {
+    std::map<SMDSAbs_ElementType,smIdType> entities;
+    entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_0DElement,
                 theObject ? theObject->GetNbEntities(SMDSAbs_0DElement) : 0));
-    entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Ball,
+    entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Ball,
                 theObject ? theObject->GetNbEntities(SMDSAbs_Ball) : 0));
-    entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Edge,
+    entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Edge,
                 theObject ? theObject->GetNbEntities(SMDSAbs_Edge) : 0));
-    entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Face,
+    entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Face,
                 theObject ? theObject->GetNbEntities(SMDSAbs_Face) : 0));
-    entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Volume,
+    entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Volume,
                 theObject ? theObject->GetNbEntities(SMDSAbs_Volume) : 0));
     return entities;
   }
index c2afc85..a6ea963 100644 (file)
@@ -84,7 +84,7 @@ SMESHOBJECT_EXPORT
               QString def);
    
  SMESHOBJECT_EXPORT
-   std::map<SMDSAbs_ElementType,int>
+   std::map<SMDSAbs_ElementType,smIdType>
    GetEntitiesFromObject(SMESH_VisualObj *theObject);
    
 SMESHOBJECT_EXPORT
index 1371d34..eb66cf1 100644 (file)
@@ -43,6 +43,7 @@
 #include <vtkRenderer.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkCellData.h>
+#include <iostream>
 
 vtkStandardNewMacro(SMESH_CellLabelActor)
 
@@ -70,7 +71,7 @@ SMESH_CellLabelActor::SMESH_CellLabelActor()
   myClsLabeledDataMapper = vtkLabeledDataMapper::New();
   myClsLabeledDataMapper->SetInputConnection(myClsSelectVisiblePoints->GetOutputPort());
 
-  myClsLabeledDataMapper->SetLabelFormat("%d");
+  //myClsLabeledDataMapper->SetLabelFormat("%d");
   myClsLabeledDataMapper->SetLabelModeToLabelScalars();
 
   myClsTextProp = vtkTextProperty::New();
@@ -156,18 +157,18 @@ void SMESH_CellLabelActor::SetCellsLabeled(bool theIsCellsLabeled)
   {
     myCellsNumDataSet->ShallowCopy(aGrid);
     vtkUnstructuredGrid *aDataSet = myCellsNumDataSet;
-    int aNbElem = aDataSet->GetNumberOfCells();
-    vtkIntArray *anArray = vtkIntArray::New();
+    vtkIdType aNbElem = aDataSet->GetNumberOfCells();
+    vtkIdTypeArray *anArray = vtkIdTypeArray::New();
     anArray->SetNumberOfValues(aNbElem);
     myExtractUnstructuredGrid->BuildOut2InMap();
-    for(int anId = 0; anId < aNbElem; anId++)
+    for(vtkIdType anId = 0; anId < aNbElem; anId++)
     {
       vtkIdType id = anId;
       if(IsImplicitFunctionUsed())
         id = myExtractGeometry->GetElemObjId(id);
       id = myExtractUnstructuredGrid->GetInputId(id);
       id = (id >=0) ? id : anId;
-      int aSMDSId = myVisualObj->GetElemObjId(id);
+      vtkIdType aSMDSId = myVisualObj->GetElemObjId(id);
       anArray->SetValue(anId,aSMDSId);
     }
     aDataSet->GetCellData()->SetScalars(anArray);
index 338994a..bd9f62e 100644 (file)
@@ -31,7 +31,7 @@
 #include "SMESH_ControlsDef.hxx"
 #include "SMESH_ActorUtils.h"
 #include "SMESH_FaceOrientationFilter.h"
-#include "VTKViewer_CellLocationsArray.h"
+//#include "VTKViewer_CellLocationsArray.h"
 #include "VTKViewer_PolyDataMapper.h"
 
 #include <VTKViewer_Transform.h>
@@ -161,7 +161,7 @@ SMESH_DeviceActor
 
   myTransformFilter->Delete();
 
-  for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
+  for(size_t i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
     myPassFilter[i]->Delete();
 
   myShrinkFilter->Delete();
@@ -426,7 +426,7 @@ SMESH_DeviceActor
       aCellTypesArray->SetNumberOfTuples( aNbCells );
       aScalars->SetNumberOfTuples( aNbCells );
 
-      VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
+      vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
       aCellLocationsArray->SetNumberOfComponents( 1 );
       aCellLocationsArray->SetNumberOfTuples( aNbCells );
 
@@ -491,7 +491,7 @@ SMESH_DeviceActor
       aCellTypesArray->SetNumberOfTuples( aNbCells );
       aScalars->SetNumberOfTuples( aNbCells );
 
-      VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
+      vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
       aCellLocationsArray->SetNumberOfComponents( 1 );
       aCellLocationsArray->SetNumberOfTuples( aNbCells );
 
@@ -586,7 +586,7 @@ SMESH_DeviceActor
       }
     }
     
-    VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
+    vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
     aCellLocationsArray->SetNumberOfComponents( 1 );
     aCellLocationsArray->SetNumberOfTuples( aNbCells );
     
@@ -604,7 +604,7 @@ SMESH_DeviceActor
            ( aPredicate = dynamic_cast<CoincidentNodes*>(theFunctor.get())))
   {
     myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
-    vtkIdType aNbNodes = myVisualObj->GetNbEntities(SMDSAbs_Node);
+    vtkIdType aNbNodes = FromSmIdType<vtkIdType>(myVisualObj->GetNbEntities(SMDSAbs_Node));
     for( vtkIdType i = 0; i < aNbNodes; i++ ){
       vtkIdType anObjId = myVisualObj->GetNodeObjId(i);
       if(aPredicate->IsSatisfy(anObjId))
@@ -783,6 +783,8 @@ SMESH_DeviceActor
     myGeomFilter->SetInside(false);
     myGeomFilter->SetWireframeMode(false);
     GetProperty()->SetRepresentation(theMode);
+  case eNoneRepr:
+    return;
   }
   SetMarkerEnabled(theMode == ePoint);
   myRepresentation = theMode;
@@ -839,9 +841,9 @@ SMESH_DeviceActor
 }
 
 
-int
+vtkIdType
 SMESH_DeviceActor
-::GetNodeObjId(int theVtkID)
+::GetNodeObjId(vtkIdType theVtkID)
 {
   vtkIdType anID = theVtkID;
 
@@ -855,7 +857,7 @@ SMESH_DeviceActor
 
 double* 
 SMESH_DeviceActor
-::GetNodeCoord(int theObjID)
+::GetNodeCoord(vtkIdType theObjID)
 {
   vtkDataSet* aDataSet = myMergeFilter->GetOutput();
   vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
@@ -864,16 +866,16 @@ SMESH_DeviceActor
   return aCoord;
 }
 
-int
+vtkIdType
 SMESH_DeviceActor
-::GetNodeVtkId(int theObjID) 
+::GetNodeVtkId(vtkIdType theObjID) 
 {
   return myVisualObj->GetNodeVTKId(theObjID);
 }
 
-int
+vtkIdType
 SMESH_DeviceActor
-::GetElemObjId(int theVtkID)
+::GetElemObjId(vtkIdType theVtkID)
 {
   vtkIdType anId = myGeomFilter->GetElemObjId(theVtkID);
   if(anId < 0) 
@@ -897,7 +899,7 @@ SMESH_DeviceActor
 
 vtkCell* 
 SMESH_DeviceActor
-::GetElemCell(int theObjID)
+::GetElemCell(vtkIdType theObjID)
 {
   vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid();
   vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);
index 3192a58..1e863a6 100644 (file)
@@ -68,12 +68,12 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   void SetStoreGemetryMapping(bool theStoreMapping);
   void SetStoreIDMapping(bool theStoreMapping);
 
-  virtual int GetNodeObjId(int theVtkID);
-  virtual double* GetNodeCoord(int theObjID);
-  virtual int GetNodeVtkId(int theObjID);
+  virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
+  virtual double* GetNodeCoord(vtkIdType theObjID);
+  virtual vtkIdType GetNodeVtkId(vtkIdType theObjID);
 
-  virtual int GetElemObjId(int theVtkID);
-  virtual vtkCell* GetElemCell(int theObjID);
+  virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
+  virtual vtkCell* GetElemCell(vtkIdType theObjID);
 
   virtual void SetTransform(VTKViewer_Transform* theTransform); 
   virtual vtkMTimeType GetMTime();
@@ -108,7 +108,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   void SetShrink(); 
   void UnShrink(); 
 
-  enum EReperesent { ePoint, eWireframe, eSurface, eInsideframe};
+  enum EReperesent { ePoint, eWireframe, eSurface, eInsideframe, eNoneRepr=-1};
   EReperesent GetRepresentation(){ return myRepresentation;}
   void SetRepresentation(EReperesent theMode);
 
index 06dda5b..3b09ed0 100644 (file)
@@ -58,16 +58,16 @@ SMESH_ExtractGeometry::SMESH_ExtractGeometry()
 SMESH_ExtractGeometry::~SMESH_ExtractGeometry()
 {}
 
-vtkIdType SMESH_ExtractGeometry::GetElemObjId(int theVtkID)
+vtkIdType SMESH_ExtractGeometry::GetElemObjId(vtkIdType theVtkID)
 {
-  if( theVtkID < 0 || theVtkID >= (int)myElemVTK2ObjIds.size()) return -1;
+  if( theVtkID < 0 || theVtkID >= myElemVTK2ObjIds.size()) return -1;
   return myElemVTK2ObjIds[theVtkID];
 }
 
 
-vtkIdType SMESH_ExtractGeometry::GetNodeObjId(int theVtkID)
+vtkIdType SMESH_ExtractGeometry::GetNodeObjId(vtkIdType theVtkID)
 {
-  if ( theVtkID < 0 || theVtkID >= (int)myNodeVTK2ObjIds.size()) return -1;
+  if ( theVtkID < 0 || theVtkID >= myNodeVTK2ObjIds.size()) return -1;
   return myNodeVTK2ObjIds[theVtkID];
 }
 
index 619d40c..be636fb 100644 (file)
@@ -42,8 +42,8 @@ public:
   }
   bool GetStoreMapping(){ return myStoreMapping;}
 
-  virtual vtkIdType GetNodeObjId(int theVtkID);
-  virtual vtkIdType GetElemObjId(int theVtkID);
+  virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
+  virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
 
 protected:
   SMESH_ExtractGeometry();
index 5b5a938..4ac4c90 100644 (file)
@@ -61,7 +61,7 @@ SMESH_NodeLabelActor::SMESH_NodeLabelActor()
 
   myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
   myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
-  myPtsLabeledDataMapper->SetLabelFormat("%d");
+  //myPtsLabeledDataMapper->SetLabelFormat("%d");
   myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
 
   myPtsTextProp = vtkTextProperty::New();
@@ -145,18 +145,18 @@ void SMESH_NodeLabelActor::SetPointsLabeled(bool theIsPointsLabeled)
   {
     myPointsNumDataSet->ShallowCopy(aGrid);
     vtkUnstructuredGrid *aDataSet = myPointsNumDataSet;
-    
-    int aNbElem = aDataSet->GetNumberOfPoints();
-    
-    vtkIntArray *anArray = vtkIntArray::New();
+
+    vtkIdType aNbElem = aDataSet->GetNumberOfPoints();
+
+    vtkIdTypeArray *anArray = vtkIdTypeArray::New();
     anArray->SetNumberOfValues( aNbElem );
-    
+
     for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
     {
-      int aSMDSId = myVisualObj->GetNodeObjId( anId );
+      vtkIdType aSMDSId = myVisualObj->GetNodeObjId( anId );
       anArray->SetValue( anId, aSMDSId );
     }
-    
+
     aDataSet->GetPointData()->SetScalars( anArray );
     myPtsMaskPoints->SetInputData( aDataSet );
     myPointLabels->SetVisibility( GetVisibility() );
index af6410d..6f8551d 100644 (file)
@@ -38,7 +38,7 @@
 
 #include <SalomeApp_Application.h>
 #include <VTKViewer_ExtractUnstructuredGrid.h>
-#include <VTKViewer_CellLocationsArray.h>
+//#include <VTKViewer_CellLocationsArray.h>
 
 #include CORBA_SERVER_HEADER(SMESH_Gen)
 #include CORBA_SERVER_HEADER(SALOME_Exception)
@@ -103,7 +103,7 @@ SMESH_VisualObjDef::~SMESH_VisualObjDef()
 // functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
 // purpose   : Methods for retrieving VTK IDs by SMDS IDs and  vice versa
 //=================================================================================
-vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
+vtkIdType SMESH_VisualObjDef::GetNodeObjId( vtkIdType theVTKID )
 {
   if (myLocalGrid)
   {
@@ -114,10 +114,10 @@ vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
   if( this->GetMesh() )
     aNode = this->GetMesh()->FindNodeVtk( theVTKID );
 
-  return aNode ? aNode->GetID() : -1;
+  return aNode ? FromSmIdType<vtkIdType>(aNode->GetID()) : -1;
 }
 
-vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
+vtkIdType SMESH_VisualObjDef::GetNodeVTKId( vtkIdType theObjID )
 {
   if (myLocalGrid)
   {
@@ -132,17 +132,17 @@ vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
   return aNode ? aNode->GetVtkID() : -1;
 }
 
-vtkIdType SMESH_VisualObjDef::GetElemObjId( int theVTKID )
+vtkIdType SMESH_VisualObjDef::GetElemObjId( vtkIdType theVTKID )
 {
   if (myLocalGrid)
   {
     TMapOfIds::const_iterator i = myVTK2SMDSElems.find(theVTKID);
     return i == myVTK2SMDSElems.end() ? -1 : i->second;
   }
-  return this->GetMesh()->FromVtkToSmds(theVTKID);
+  return FromSmIdType<vtkIdType>(this->GetMesh()->FromVtkToSmds(theVTKID));
 }
 
-vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
+vtkIdType SMESH_VisualObjDef::GetElemVTKId( vtkIdType theObjID )
 {
   if (myLocalGrid)
   {
@@ -171,7 +171,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
     return;
 
   TEntityList aNodes;
-  vtkIdType nbNodes = GetEntities( SMDSAbs_Node, aNodes );
+  vtkIdType nbNodes = FromSmIdType<vtkIdType>(GetEntities( SMDSAbs_Node, aNodes ));
   thePoints->SetNumberOfPoints( nbNodes );
 
   int nbPoints = 0;
@@ -183,7 +183,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
     if ( aNode != 0 )
     {
       thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
-      int anId = aNode->GetID();
+      smIdType anId = aNode->GetID();
       mySMDS2VTKNodes.insert( mySMDS2VTKNodes.end(), std::make_pair( anId, nbPoints ));
       myVTK2SMDSNodes.insert( myVTK2SMDSNodes.end(), std::make_pair( nbPoints, anId ));
       nbPoints++;
@@ -284,7 +284,7 @@ namespace{
     theConnect.clear();
     for(; theNodesIter->more();)
       theConnect.push_back(theNodesIter->next());
-    return theConnect.size();
+    return (int) theConnect.size();
   }
   
   inline 
@@ -292,7 +292,7 @@ namespace{
              const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes, 
              const TConnect& theConnect, 
              int thePosition,
-             int theId)
+             vtkIdType theId)
   {
     theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
   }
@@ -319,7 +319,7 @@ void SMESH_VisualObjDef::buildElemPrs()
     { SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
 
   // get entity data
-  map<SMDSAbs_ElementType,int> nbEnts;
+  map<SMDSAbs_ElementType,smIdType> nbEnts;
   map<SMDSAbs_ElementType,TEntityList> anEnts;
 
   vtkIdType aNbCells = 0;
@@ -404,9 +404,9 @@ void SMESH_VisualObjDef::buildElemPrs()
 
         vtkIdType aNbNodes = anElem->NbNodes();
         anIdList->SetNumberOfIds( aNbNodes );
-        const vtkIdType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
+        const VTKCellType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
 
-        int anId = anElem->GetID();
+        smIdType anId = anElem->GetID();
 
         mySMDS2VTKElems.insert( mySMDS2VTKElems.end(), std::make_pair( anId, iElem ));
         myVTK2SMDSElems.insert( myVTK2SMDSElems.end(), std::make_pair( iElem, anId ));
@@ -424,7 +424,7 @@ void SMESH_VisualObjDef::buildElemPrs()
                 anIdList->InsertNextId(ph->NbFaceNodes(i));
                 for(int j = 1; j <= ph->NbFaceNodes(i); j++) {
                   if ( const SMDS_MeshNode* n = ph->GetFaceNode( i, j ))
-                    anIdList->InsertNextId( mySMDS2VTKNodes[ n->GetID() ]);
+                    anIdList->InsertNextId( mySMDS2VTKNodes[ FromSmIdType<vtkIdType>(n->GetID()) ]);
                 }
               }
             }
@@ -435,13 +435,13 @@ void SMESH_VisualObjDef::buildElemPrs()
             if (aConnectivities.size() > 0) {
               aConnect.clear();
               GetConnect(aNodesIter,aConnect);
-              for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
+              for (int aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
                 SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
             }
             else {
               for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
                 const SMDS_MeshElement* aNode = aNodesIter->next();
-                anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
+                anIdList->SetId( aNodeId, mySMDS2VTKNodes[FromSmIdType<vtkIdType>(aNode->GetID())]);
               }
             }
           }
@@ -465,7 +465,7 @@ void SMESH_VisualObjDef::buildElemPrs()
 
   // Insert cells in grid
 
-  VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
+  vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
   aCellLocationsArray->SetNumberOfComponents( 1 );
   aCellLocationsArray->SetNumberOfTuples( aNbCells );
 
@@ -491,10 +491,10 @@ void SMESH_VisualObjDef::buildElemPrs()
 // function : GetEdgeNodes
 // purpose  : Retrieve ids of nodes from edge of elements ( edge is numbered from 0 )
 //=================================================================================
-bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
-                                       const int theEdgeNum,
-                                       int&      theNodeId1,
-                                       int&      theNodeId2 ) const
+bool SMESH_VisualObjDef::GetEdgeNodes( const smIdType theElemId,
+                                       const int      theEdgeNum,
+                                       smIdType&      theNodeId1,
+                                       smIdType&      theNodeId2 ) const
 {
   const SMDS_Mesh* aMesh = GetMesh();
   if ( aMesh == 0 )
@@ -557,7 +557,7 @@ void SMESH_VisualObjDef::updateEntitiesFlags()
   unsigned int tmp = myEntitiesState;
   ClearEntitiesFlags();
 
-  map<SMDSAbs_ElementType,int> entities = SMESH::GetEntitiesFromObject(this);
+  map<SMDSAbs_ElementType,smIdType> entities = SMESH::GetEntitiesFromObject(this);
 
 
   if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||
@@ -681,7 +681,7 @@ bool SMESH_MeshObj::NulData()
 // function : GetElemDimension
 // purpose  : Get dimension of element
 //=================================================================================
-int SMESH_MeshObj::GetElemDimension( const int theObjId )
+int SMESH_MeshObj::GetElemDimension( const smIdType theObjId )
 {
   const SMDS_MeshElement* anElem = myClient->FindElement( theObjId );
   if ( anElem == 0 )
@@ -703,7 +703,7 @@ int SMESH_MeshObj::GetElemDimension( const int theObjId )
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   switch ( theType )
   {
@@ -742,7 +742,7 @@ int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   }
 }
 
-int SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
+smIdType SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
 {
   theObjs.clear();
 
@@ -834,7 +834,7 @@ SMESH_SubMeshObj::~SMESH_SubMeshObj()
 // function : GetElemDimension
 // purpose  : Get dimension of element
 //=================================================================================
-int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
+int SMESH_SubMeshObj::GetElemDimension( const smIdType theObjId )
 {
   return myMeshObj == 0 ? 0 : myMeshObj->GetElemDimension( theObjId );
 }
@@ -908,13 +908,13 @@ SMDSAbs_ElementType SMESH_GroupObj::GetElementType() const
 // function : getNodesFromElems
 // purpose  : Retrieve nodes from elements
 //=================================================================================
-static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
+static int getNodesFromElems( SMESH::smIdType_array_var&          theElemIds,
                               const SMDS_Mesh*                    theMesh,
                               std::list<const SMDS_MeshElement*>& theResList )
 {
   set<const SMDS_MeshElement*> aNodeSet;
 
-  for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+  for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
   {
     const SMDS_MeshElement* anElem = theMesh->FindElement( theElemIds[ i ] );
     if ( anElem != 0 )
@@ -929,11 +929,9 @@ static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
     }
   }
 
-  set<const SMDS_MeshElement*>::const_iterator anIter;
-  for ( anIter = aNodeSet.begin(); anIter != aNodeSet.end(); ++anIter )
-    theResList.push_back( *anIter );
+  theResList.assign( aNodeSet.begin(), aNodeSet.end() );
 
-  return theResList.size();    
+  return (int) aNodeSet.size();
 }
 
 //=================================================================================
@@ -941,11 +939,11 @@ static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
 // purpose  : Get std::list<const SMDS_MeshElement*> from list of IDs
 //=================================================================================
 static int getPointers( const SMDSAbs_ElementType           theRequestType,
-                        SMESH::long_array_var&              theElemIds,
+                        SMESH::smIdType_array_var&          theElemIds,
                         const SMDS_Mesh*                    theMesh,
                         std::list<const SMDS_MeshElement*>& theResList )
 {
-  for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+  for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
   {
     const SMDS_MeshElement* anElem = theRequestType == SMDSAbs_Node
       ? theMesh->FindNode( theElemIds[ i ] ) : theMesh->FindElement( theElemIds[ i ] );
@@ -954,7 +952,7 @@ static int getPointers( const SMDSAbs_ElementType           theRequestType,
       theResList.push_back( anElem );
   }
 
-  return theResList.size();
+  return (int) theResList.size();
 }
 
 
@@ -962,7 +960,7 @@ static int getPointers( const SMDSAbs_ElementType           theRequestType,
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType) {
     return myGroupServer->Size();
@@ -973,11 +971,11 @@ int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   return 0;
 }
 
-int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
+smIdType SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
 {
   theResList.clear();
   SMDS_Mesh* aMesh = myMeshObj->GetMesh();
-  
+
   if ( aMesh == 0 )
     return 0;
 
@@ -985,7 +983,7 @@ int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList&
   if ( aGrpType != theType && theType != SMDSAbs_Node )
     return 0;
 
-  SMESH::long_array_var anIds = myGroupServer->GetListOfID();
+  SMESH::smIdType_array_var anIds = myGroupServer->GetListOfID();
   if ( anIds->length() == 0 )
     return 0;
 
@@ -1028,7 +1026,7 @@ SMESH_subMeshObj::~SMESH_subMeshObj()
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   switch ( theType )
   {
@@ -1043,7 +1041,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
     case SMDSAbs_Face:
     case SMDSAbs_Volume:
     {
-      SMESH::long_array_var anIds = 
+      SMESH::smIdType_array_var anIds = 
         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
       return anIds->length();
     }
@@ -1053,7 +1051,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   }
 }
 
-int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
+smIdType SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
 {
   theResList.clear();
 
@@ -1067,7 +1065,7 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
   {
     if ( theType == SMDSAbs_Node )
     {
-      SMESH::long_array_var anIds = mySubMeshServer->GetNodesId();
+      SMESH::smIdType_array_var anIds = mySubMeshServer->GetNodesId();
       return getPointers( SMDSAbs_Node, anIds, aMesh, theResList );
     }
   }
@@ -1075,12 +1073,12 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
   {
     if ( theType == SMDSAbs_Node )
     {
-      SMESH::long_array_var anIds = mySubMeshServer->GetElementsId();
+      SMESH::smIdType_array_var anIds = mySubMeshServer->GetElementsId();
       return getNodesFromElems( anIds, aMesh, theResList );
     }
     else
     {
-      SMESH::long_array_var anIds = 
+      SMESH::smIdType_array_var anIds = 
         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
       return getPointers( theType, anIds, aMesh, theResList );
     }
index 9ef8772..f92f19c 100644 (file)
@@ -45,6 +45,7 @@
 #include "SMDSAbs_ElementType.hxx"
 
 #include <SALOMEconfig.h>
+#include <smIdType.hxx>
 #include CORBA_SERVER_HEADER(SMESH_Mesh)
 
 class SMDS_Mesh;
@@ -61,24 +62,24 @@ public:
   virtual bool Update( int theIsClear = true ) = 0;
   virtual bool NulData() = 0;
   virtual void UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor ) = 0;
-  virtual int GetElemDimension( const int theObjId ) = 0;
+  virtual int GetElemDimension( const smIdType theObjId ) = 0;
 
-  virtual int GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
+  virtual smIdType GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
   virtual SMDS_Mesh* GetMesh() const = 0;
   virtual SMESH::SMESH_Mesh_ptr GetMeshServer() = 0;
 
-  virtual bool GetEdgeNodes( const int theElemId,
-                             const int theEdgeNum,
-                             int&      theNodeId1,
-                             int&      theNodeId2 ) const = 0;
+  virtual bool GetEdgeNodes( const smIdType theElemId,
+                             const int      theEdgeNum,
+                             smIdType&      theNodeId1,
+                             smIdType&      theNodeId2 ) const = 0;
   virtual bool              IsValid() const = 0;
   
   virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
   
-  virtual vtkIdType GetNodeObjId( int theVTKID ) = 0;
-  virtual vtkIdType GetNodeVTKId( int theObjID ) = 0;
-  virtual vtkIdType GetElemObjId( int theVTKID ) = 0;
-  virtual vtkIdType GetElemVTKId( int theObjID ) = 0;
+  virtual vtkIdType GetNodeObjId( vtkIdType theVTKID ) = 0;
+  virtual vtkIdType GetNodeVTKId( vtkIdType theObjID ) = 0;
+  virtual vtkIdType GetElemObjId( vtkIdType theVTKID ) = 0;
+  virtual vtkIdType GetElemVTKId( vtkIdType theObjID ) = 0;
   virtual void              ClearEntitiesFlags() = 0;
   virtual bool              GetEntitiesFlag() = 0;
   virtual unsigned int      GetEntitiesState() = 0;
index 879384e..75ac529 100644 (file)
@@ -63,27 +63,27 @@ public:
   virtual bool              Update( int theIsClear = true ) = 0;
   virtual bool              NulData() {return 0; };
   virtual void              UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor ) = 0;
-  virtual int               GetElemDimension( const int theObjId ) = 0;
+  virtual int               GetElemDimension( const smIdType theObjId ) = 0;
 
-  virtual int               GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
-  virtual int               GetEntities( const SMDSAbs_ElementType, TEntityList& ) const = 0;
+  virtual smIdType          GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
+  virtual smIdType          GetEntities( const SMDSAbs_ElementType, TEntityList& ) const = 0;
   virtual bool              IsNodePrs() const = 0;
   virtual SMDS_Mesh*        GetMesh() const = 0;
   virtual SMESH::SMESH_Mesh_ptr GetMeshServer() = 0;
 
   virtual bool              IsValid() const;
 
-  virtual bool              GetEdgeNodes( const int theElemId,
-                                          const int theEdgeNum,
-                                          int&      theNodeId1,
-                                          int&      theNodeId2 ) const;
+  virtual bool              GetEdgeNodes( const smIdType theElemId,
+                                          const int      theEdgeNum,
+                                          smIdType&      theNodeId1,
+                                          smIdType&      theNodeId2 ) const;
 
   virtual vtkUnstructuredGrid* GetUnstructuredGrid();
   
-  virtual vtkIdType         GetNodeObjId( int theVTKID );
-  virtual vtkIdType         GetNodeVTKId( int theObjID );
-  virtual vtkIdType         GetElemObjId( int theVTKID );
-  virtual vtkIdType         GetElemVTKId( int theObjID );
+  virtual vtkIdType         GetNodeObjId( vtkIdType theVTKID );
+  virtual vtkIdType         GetNodeVTKId( vtkIdType theObjID );
+  virtual vtkIdType         GetElemObjId( vtkIdType theVTKID );
+  virtual vtkIdType         GetElemVTKId( vtkIdType theObjID );
   
   virtual void              ClearEntitiesFlags();
   virtual bool              GetEntitiesFlag();
@@ -108,7 +108,7 @@ protected:
   unsigned int              myEntitiesState;
 
   vtkUnstructuredGrid*      myGrid;
-  std::map<SMDSAbs_ElementType,int> myEntitiesCache;
+  std::map<SMDSAbs_ElementType,smIdType> myEntitiesCache;
 };
 
 
@@ -127,11 +127,11 @@ public:
   virtual bool              Update( int theIsClear = true );
   virtual bool              NulData();
   
-  virtual int               GetNbEntities( const SMDSAbs_ElementType) const;
-  virtual int               GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
+  virtual smIdType          GetNbEntities( const SMDSAbs_ElementType) const;
+  virtual smIdType          GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
   virtual bool              IsNodePrs() const;
 
-  virtual int               GetElemDimension( const int theObjId );
+  virtual int               GetElemDimension( const smIdType theObjId );
 
   virtual void              UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor );
   
@@ -160,7 +160,7 @@ public:
   virtual bool              Update( int theIsClear = true );
   
   virtual void              UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor );
-  virtual int               GetElemDimension( const int theObjId );
+  virtual int               GetElemDimension( const smIdType theObjId );
   virtual SMDS_Mesh*        GetMesh() const { return myMeshObj->GetMesh(); }
   virtual SMESH::SMESH_Mesh_ptr GetMeshServer() { return myMeshObj->GetMeshServer(); }
   
@@ -181,8 +181,8 @@ public:
                             SMESH_GroupObj( SMESH::SMESH_GroupBase_ptr, SMESH_MeshObj* );
   virtual                   ~SMESH_GroupObj();
 
-  virtual int               GetNbEntities( const SMDSAbs_ElementType) const;
-  virtual int               GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
+  virtual smIdType          GetNbEntities( const SMDSAbs_ElementType) const;
+  virtual smIdType          GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
   virtual bool              IsNodePrs() const;
 
   virtual SMDSAbs_ElementType GetElementType() const;
@@ -206,8 +206,8 @@ public:
                                               SMESH_MeshObj* );
   virtual                   ~SMESH_subMeshObj();
 
-  virtual int               GetNbEntities( const SMDSAbs_ElementType) const;
-  virtual int               GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
+  virtual smIdType          GetNbEntities( const SMDSAbs_ElementType) const;
+  virtual smIdType          GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
   virtual bool              IsNodePrs() const;    
   
 protected:
index 67e5741..32e966c 100644 (file)
@@ -108,7 +108,7 @@ SMESH_SVTKActor
 void
 SMESH_SVTKActor
 ::MapCells(SALOME_Actor* theMapActor,
-           const TColStd_IndexedMapOfInteger& theMapIndex)
+           const SVTK_TIndexedMapOfVtkId& theMapIndex)
 {
   myUnstructuredGrid->Initialize();
   myUnstructuredGrid->Allocate();
@@ -134,8 +134,9 @@ SMESH_SVTKActor
     cd = aSourceGrid->GetCellData();
   }
   outputCD->CopyAllocate(cd,aNbOfParts,aNbOfParts/2);
-  for(int ind = 1; ind <= aNbOfParts; ind++){
-    int aPartId = theMapIndex( ind );
+  for(int ind = 1; ind <= aNbOfParts; ind++)
+  {
+    vtkIdType aPartId = theMapIndex( ind );
     if(vtkCell* aCell = theMapActor->GetElemCell(aPartId))
     {
       if (aCell->GetCellType() != VTK_POLYHEDRON)
index 8c13b08..41969e6 100644 (file)
@@ -61,7 +61,7 @@ public:
   //! Allow to recostruct selected cells from source SALOME_Actor and map of subindexes
   virtual void
   MapCells(SALOME_Actor* theMapActor,
-           const TColStd_IndexedMapOfInteger& theMapIndex);
+           const SVTK_TIndexedMapOfVtkId& theMapIndex);
 
 
   //! To remove the actor an all its internal devices
index 2ef5cce..0436bdf 100644 (file)
@@ -30,7 +30,7 @@
 void SMDS_BallElement::init(const SMDS_MeshNode * node, double diameter )
 {
   vtkIdType nodeVtkID = node->GetVtkID();
-  int vtkID = getGrid()->InsertNextLinkedCell( toVtkType( SMDSEntity_Ball ), 1, &nodeVtkID );
+  vtkIdType vtkID = getGrid()->InsertNextLinkedCell( toVtkType( SMDSEntity_Ball ), 1, &nodeVtkID );
   setVtkID( vtkID );
   getGrid()->SetBallDiameter( GetVtkID(), diameter );
 }
index 0260346..f399834 100644 (file)
 
 #include "SMDS_CellOfNodes.hxx"
 
-SMDS_CellOfNodes::SMDS_CellOfNodes( int id, int shapeID )
+SMDS_CellOfNodes::SMDS_CellOfNodes( smIdType id, int shapeID )
   : myID( id )
 {
   setShapeID( shapeID );
 }
 
-void SMDS_CellOfNodes::setID(const int id)
+void SMDS_CellOfNodes::setID(const smIdType id)
 {
   myID = id;
 }
 
-int SMDS_CellOfNodes::GetID() const
+smIdType SMDS_CellOfNodes::GetID() const
 {
   return myID;
 }
index 9c18353..4282e64 100644 (file)
@@ -31,6 +31,8 @@
         
 #include "SMDS_MeshElement.hxx"
 
+#include <smIdType.hxx>
+
 // ============================================================
 /*!
  * \brief Base class for elements not contained in the mesh
@@ -42,8 +44,8 @@ class SMDS_EXPORT SMDS_CellOfNodes : public SMDS_MeshElement
 {
 public:
 
-  virtual int GetID() const;
-  virtual int GetShapeID() const;
+  virtual smIdType GetID() const;
+  virtual int      GetShapeID() const;
 
   virtual void setIsMarked( bool is ) const;
   virtual bool isMarked() const;
@@ -52,13 +54,13 @@ public:
 
  protected:
 
-  SMDS_CellOfNodes( int id = -1, int shapeID = 0);
+  SMDS_CellOfNodes( smIdType id = -1, int shapeID = 0);
 
-  virtual void setID( const int id);
+  virtual void setID( const smIdType id);
   virtual void setShapeID( const int shapeID );
 
-  int  myID;
-  int  myShapeID;
+  smIdType  myID;
+  int       myShapeID;
 
   enum Bits { // use the 1st right bit of myShapeId to set/unset a mark
     BIT_IS_MARKED = 1,
index 76c7191..d2152f2 100644 (file)
@@ -27,6 +27,7 @@
 
 #include <vtkCellType.h>
 #include <vtkCellLinks.h>
+#include <smIdType.hxx>
 
 #include <map>
 
@@ -232,7 +233,7 @@ void SMDS_Down1D::compactStorage()
   _cellIds.resize(_nbDownCells * _maxId);
   _vtkCellIds.resize(_maxId);
 
-  int sizeUpCells = 0;
+  smIdType sizeUpCells = 0;
   for (int i = 0; i < _maxId; i++)
     sizeUpCells += _upCellIdsVector[i].size();
   _upCellIds.resize(sizeUpCells, -1);
@@ -258,8 +259,8 @@ void SMDS_Down1D::compactStorage()
 void SMDS_Down1D::addUpCell(int cellId, int upCellId, unsigned char aType)
 {
   //ASSERT((cellId >=0) && (cellId < _maxId));
-  int nbFaces = _upCellIdsVector[cellId].size();
-  for (int i = 0; i < nbFaces; i++)
+  smIdType nbFaces = _upCellIdsVector[cellId].size();
+  for (smIdType i = 0; i < nbFaces; i++)
     {
       if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType))
         {
index e6518d7..e5e29e0 100644 (file)
@@ -104,15 +104,15 @@ int SMDS_ElementFactory::ChunkSize()
 //================================================================================
 /*!
  * \brief Return minimal ID of a non-used element
- *  \return int - minimal element ID
+ *  \return smIdType - minimal element ID
  */
 //================================================================================
 
-int SMDS_ElementFactory::GetFreeID()
+smIdType SMDS_ElementFactory::GetFreeID()
 {
   if ( myChunksWithUnused.empty() )
   {
-    int id0 = myChunks.size() * theChunkSize + 1;
+    smIdType id0 = myChunks.size() * theChunkSize + 1;
     myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
   }
   SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
@@ -122,15 +122,15 @@ int SMDS_ElementFactory::GetFreeID()
 //================================================================================
 /*!
  * \brief Return maximal ID of an used element
- *  \return int - element ID
+ *  \return smIdType - element ID
  */
 //================================================================================
 
-int SMDS_ElementFactory::GetMaxID()
+smIdType SMDS_ElementFactory::GetMaxID()
 {
-  int id = 0;
+  smIdType id = 0;
   TIndexRanges usedRanges;
-  for ( int i = myChunks.size() - 1; i >= 0; --i )
+  for ( smIdType i = myChunks.size() - 1; i >= 0; --i )
     if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
     {
       int index = usedRanges.back().second-1;
@@ -143,13 +143,13 @@ int SMDS_ElementFactory::GetMaxID()
 //================================================================================
 /*!
  * \brief Return minimal ID of an used element
- *  \return int - element ID
+ *  \return smIdType - element ID
  */
 //================================================================================
 
-int SMDS_ElementFactory::GetMinID()
+smIdType SMDS_ElementFactory::GetMinID()
 {
-  int id = 0;
+  smIdType id = 0;
   TIndexRanges usedRanges;
   for ( size_t i = 0; i < myChunks.size(); ++i )
     if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
@@ -169,20 +169,20 @@ int SMDS_ElementFactory::GetMinID()
  */
 //================================================================================
 
-SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
+SMDS_MeshElement* SMDS_ElementFactory::NewElement( const smIdType id )
 {
-  int iChunk = ( id - 1 ) / theChunkSize;
-  int index  = ( id - 1 ) % theChunkSize;
-  while ((int) myChunks.size() <= iChunk )
+  smIdType iChunk = ( id - 1 ) / theChunkSize;
+  smIdType index  = ( id - 1 ) % theChunkSize;
+  while ((smIdType) myChunks.size() <= iChunk )
   {
-    int id0 = myChunks.size() * theChunkSize + 1;
+    smIdType id0 = myChunks.size() * theChunkSize + 1;
     myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
   }
-  SMDS_MeshElement* e = myChunks[iChunk].Element( index );
+  SMDS_MeshElement* e = myChunks[iChunk].Element( FromSmIdType<int>(index) );
   if ( !e->IsNull() )
     return 0; // element with given ID already exists
 
-  myChunks[iChunk].UseElement( index );
+  myChunks[iChunk].UseElement( FromSmIdType<int>(index) );
   ++myNbUsedElements;
 
   e->myHolder = & myChunks[iChunk];
@@ -200,15 +200,15 @@ SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
  */
 //================================================================================
 
-const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
+const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const smIdType id ) const
 {
   if ( id > 0 )
   {
-    int iChunk = ( id - 1 ) / theChunkSize;
-    int index  = ( id - 1 ) % theChunkSize;
-    if ( iChunk < (int) myChunks.size() )
+    smIdType iChunk = ( id - 1 ) / theChunkSize;
+    smIdType index  = ( id - 1 ) % theChunkSize;
+    if ( iChunk < (smIdType) myChunks.size() )
     {
-      const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
+      const SMDS_MeshElement* e = myChunks[iChunk].Element( FromSmIdType<int>(index) );
       return e->IsNull() ? 0 : e;
     }
   }
@@ -219,11 +219,11 @@ const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
 /*!
  * \brief Return an SMDS ID by a Vtk one
  *  \param [inout] vtkID - Vtk ID
- *  \return int - SMDS ID
+ *  \return smIdType - SMDS ID
  */
 //================================================================================
 
-int SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
+smIdType SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
 {
   if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() )
     return mySmdsIDs[vtkID] + 1;
@@ -281,11 +281,11 @@ void SMDS_ElementFactory::Clear()
  */
 //================================================================================
 
-void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
+void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
 {
-  int  newNbCells = NbUsedElements();
-  int   maxCellID = GetMaxID();
-  int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
+  smIdType  newNbCells = NbUsedElements();
+  smIdType   maxCellID = GetMaxID();
+  smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
 
   theVtkIDsNewToOld.resize( newNbCells );
 
@@ -295,7 +295,7 @@ void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
   }
   else if ( newNbCells == maxCellID ) // no holes
   {
-    int newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
+    smIdType newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
     for ( newID = 0; newID < minLastID; ++newID )
       theVtkIDsNewToOld[ newID ] = myVtkIDs[ newID ];
     for ( ; newID < newNbCells; ++newID )
@@ -303,8 +303,8 @@ void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
   }
   else // there are holes in SMDS IDs
   {
-    int newVtkID = 0; // same as new smds ID (-1)
-    for ( int oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
+    smIdType newVtkID = 0; // same as new smds ID (-1)
+    for ( smIdType oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
     {
       const SMDS_MeshElement* oldElem = FindElement( oldID );
       if ( !oldElem ) continue;
@@ -377,16 +377,16 @@ SMDS_NodeFactory::~SMDS_NodeFactory()
  */
 //================================================================================
 
-void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
+void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
 {
   // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
   // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
   // theVtkIDsOldToNew[ old VtkID ] = new VtkID
 
-  int  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
-  int  newNbNodes = NbUsedElements();
-  int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
-  int   maxNodeID = GetMaxID();
+  smIdType  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
+  smIdType  newNbNodes = NbUsedElements();
+  smIdType newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
+  smIdType   maxNodeID = GetMaxID();
 
   theVtkIDsOldToNew.resize( oldNbNodes, -1 );
 
@@ -408,13 +408,13 @@ void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
         const SMDS_MeshElement* newNode = FindElement( newID+1 );
         if ( !newNode )
           newNode = NewElement( newID+1 );
-        int  shapeID = oldNode->GetShapeID();
-        int shapeDim = GetShapeDim( shapeID );
-        int   iChunk = newID / theChunkSize;
+        int     shapeID = oldNode->GetShapeID();
+        int    shapeDim = GetShapeDim( shapeID );
+        smIdType iChunk = newID / theChunkSize;
         myChunks[ iChunk ].SetShapeID( newNode, shapeID );
         if ( shapeDim == 2 || shapeDim == 1 )
         {
-          int iChunkOld = oldID / theChunkSize;
+          smIdType iChunkOld = oldID / theChunkSize;
           TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
           TParam* newPos = myChunks[ iChunk    ].GetPositionPtr( newNode, /*allocate=*/true );
           if ( oldPos )
@@ -431,7 +431,7 @@ void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
   }
   else // no holes
   {
-    for ( int i = 0; i < newNbNodes; ++i )
+    for ( smIdType i = 0; i < newNbNodes; ++i )
       theVtkIDsOldToNew[ i ] = i;
   }
   myChunks.resize( newNbChunks );
@@ -514,7 +514,7 @@ void SMDS_NodeFactory::SetShapeDim( int shapeID, int dim )
  */
 //================================================================================
 
-SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ):
+SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, smIdType id0 ):
   myFactory( factory ),
   my1stID( id0 )//,
   //mySubIDSet( 0 )
@@ -565,7 +565,7 @@ void SMDS_ElementChunk::UseElement( const int index )
  */
 //================================================================================
 
-int SMDS_ElementChunk::GetUnusedID() const
+smIdType SMDS_ElementChunk::GetUnusedID() const
 {
   TUsedRangeSet::set_iterator r = myUsedRanges.mySet.begin();
   for ( ; r != myUsedRanges.mySet.end(); ++r )
@@ -603,7 +603,7 @@ void SMDS_ElementChunk::Free( const SMDS_MeshElement* e )
  */
 //================================================================================
 
-int SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
+smIdType SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
 {
   return my1stID + Index( e );
 }
@@ -618,11 +618,12 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
 {
   if ( e->GetID() - 1 != vtkID )
   {
-    if ((int) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
+    if ((smIdType) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
     {
-      size_t i = myFactory->myVtkIDs.size();
+      vtkIdType i = (vtkIdType) myFactory->myVtkIDs.size();
       myFactory->myVtkIDs.resize( e->GetID() + 100 );
-      for ( ; i < myFactory->myVtkIDs.size(); ++i )
+      vtkIdType newSize = (vtkIdType) myFactory->myVtkIDs.size();
+      for ( ; i < newSize; ++i )
         myFactory->myVtkIDs[i] = i;
     }
     myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
@@ -644,10 +645,10 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
  */
 //================================================================================
 
-int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
+vtkIdType SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
 {
-  size_t dfltVtkID = e->GetID() - 1;
-  return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
+  vtkIdType dfltVtkID = FromSmIdType<vtkIdType>(e->GetID() - 1);
+  return ( dfltVtkID < (vtkIdType)myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
 }
 
 //================================================================================
index 517fc26..dcc00a3 100644 (file)
@@ -40,6 +40,8 @@
 
 #include <vtkType.h>
 
+#include <smIdType.hxx>
+
 class SMDS_ElementChunk;
 class SMDS_Mesh;
 class SMDS_MeshCell;
@@ -67,8 +69,8 @@ protected:
   TChunkVector             myChunks;           // array of chunks of elements
   TChunkPtrSet             myChunksWithUnused; // sorted chunks having unused elements
   std::vector< vtkIdType > myVtkIDs;           // myVtkIDs[ smdsID-1 ] == vtkID
-  std::vector< int >       mySmdsIDs;          // mySmdsIDs[ vtkID ] == smdsID - 1
-  int                      myNbUsedElements;   // counter of elements
+  std::vector< smIdType >  mySmdsIDs;          // mySmdsIDs[ vtkID ] == smdsID - 1
+  smIdType                 myNbUsedElements;   // counter of elements
 
   friend class SMDS_ElementChunk;
 
@@ -78,25 +80,25 @@ public:
   virtual ~SMDS_ElementFactory();
 
   //! Return minimal ID of a non-used element
-  int GetFreeID();
+  smIdType GetFreeID();
 
   //! Return maximal ID of an used element
-  int GetMaxID();
+  smIdType GetMaxID();
 
   //! Return minimal ID of an used element
-  int GetMinID();
+  smIdType GetMinID();
 
   //! Return an element by ID. NULL if the element with the given ID is already used
-  SMDS_MeshElement* NewElement( const int id );
+  SMDS_MeshElement* NewElement( const smIdType id );
 
   //! Return a SMDS_MeshCell by ID. NULL if the cell with the given ID is already used
-  SMDS_MeshCell* NewCell( const int id ) { return static_cast<SMDS_MeshCell*>( NewElement( id )); }
+  SMDS_MeshCell* NewCell( const smIdType id ) { return static_cast<SMDS_MeshCell*>( NewElement( id )); }
 
   //! Return an used element by ID. NULL if the element with the given ID is not yet used
-  const SMDS_MeshElement* FindElement( const int id ) const;
+  const SMDS_MeshElement* FindElement( const smIdType id ) const;
 
   //! Return a number of used elements
-  int NbUsedElements() const { return myNbUsedElements; }
+  smIdType NbUsedElements() const { return myNbUsedElements; }
 
   //! Return an iterator on all element filtered using a given filter.
   //  nbElemsToReturn is used to optimize by stopping the iteration as soon as
@@ -119,14 +121,14 @@ public:
   void Free( const SMDS_MeshElement* );
 
   //! Return an SMDS ID by a Vtk one
-  int FromVtkToSmds( vtkIdType vtkID );
+  smIdType FromVtkToSmds( vtkIdType vtkID );
 
   //! De-allocate all elements
   virtual void Clear();
 
   //! Remove unused elements located not at the end of the last chunk.
   //  Minimize allocated memory
-  virtual void Compact(std::vector<int>& idCellsOldToNew);
+  virtual void Compact(std::vector<smIdType>& idCellsOldToNew);
 
   //! Return true if Compact() will change IDs of elements
   virtual bool CompactChangePointers();
@@ -149,10 +151,10 @@ public:
   ~SMDS_NodeFactory();
 
   //! Return a SMDS_MeshNode by ID. NULL if the node with the given ID is already used
-  SMDS_MeshNode* NewNode( int id ) { return (SMDS_MeshNode*) NewElement(id); }
+  SMDS_MeshNode* NewNode( smIdType id ) { return (SMDS_MeshNode*) NewElement(id); }
 
   //! Return an used node by ID. NULL if the node with the given ID is not yet used
-  const SMDS_MeshNode* FindNode( int id ) { return (const SMDS_MeshNode*) FindElement(id); }
+  const SMDS_MeshNode* FindNode( smIdType id ) { return (const SMDS_MeshNode*) FindElement(id); }
 
   //! Set a total number of sub-shapes in the main shape
   void SetNbShapes( size_t nbShapes );
@@ -168,7 +170,7 @@ public:
 
   //! Remove unused nodes located not at the end of the last chunk.
   //  Minimize allocated memory
-  virtual void Compact(std::vector<int>& idNodesOldToNew);
+  virtual void Compact(std::vector<smIdType>& idNodesOldToNew);
 
   //! Return true if Compact() will change IDs of node
   virtual bool CompactChangePointers();
@@ -277,7 +279,7 @@ struct _RangeSet
       rNext = mySet.upper_bound( theIndex );
       r     = rNext - 1;
     }
-    int          rSize = Size( r ); // range size
+    int         rSize = Size( r ); // range size
     attr_t      rValue = r->myValue;
     if ( rValue == theValue )
       return rValue; // it happens while compacting
@@ -370,7 +372,7 @@ class SMDS_ElementChunk
 {
   SMDS_ElementFactory* myFactory;     // holder of this chunk
   SMDS_MeshElement*    myElements;    // array of elements
-  int                  my1stID;       // ID of myElements[0]
+  smIdType             my1stID;       // ID of myElements[0]
   TBitSet              myMarkedSet;   // mark some elements
   TUsedRangeSet        myUsedRanges;  // ranges of used/unused elements
   TSubIDRangeSet       mySubIDRanges; // ranges of elements on the same sub-shape
@@ -381,7 +383,7 @@ class SMDS_ElementChunk
 
 public:
 
-  SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, int id0 = 0 );
+  SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, smIdType id0 = 0 );
   ~SMDS_ElementChunk();
 
   //! Return an element by an index [0,ChunkSize()]
@@ -391,7 +393,7 @@ public:
   const SMDS_MeshElement* Element(int index) const { return & myElements[index]; }
 
   //! Return ID of the first non-used element
-  int  GetUnusedID() const;
+  smIdType  GetUnusedID() const;
 
   //! Mark an element as used
   void UseElement( const int index );
@@ -403,10 +405,10 @@ public:
   static bool IsUsed( const _UsedRange& r ) { return r.myValue; }
 
   //! Return index of an element in the chunk
-  int Index( const SMDS_MeshElement* e ) const { return e - myElements; }
+  int Index( const SMDS_MeshElement* e ) const { return (int)( e - myElements ); }
 
   //! Return ID of the 1st element in the chunk
-  int Get1stID() const { return my1stID; }
+  smIdType Get1stID() const { return my1stID; }
 
   //! Return pointer to on-shape-parameters of a node
   TParam* GetPositionPtr( const SMDS_MeshElement* node, bool allocate=false );
@@ -429,9 +431,9 @@ public:
 
   // Methods called by SMDS_MeshElement
 
-  int  GetID( const SMDS_MeshElement* e ) const;
+  smIdType  GetID( const SMDS_MeshElement* e ) const;
 
-  int  GetVtkID( const SMDS_MeshElement* e ) const;
+  vtkIdType  GetVtkID( const SMDS_MeshElement* e ) const;
   void SetVTKID( const SMDS_MeshElement* e, const vtkIdType id );
 
   int  GetShapeID( const SMDS_MeshElement* e ) const;
@@ -563,7 +565,7 @@ SMDS_ElementFactory::GetShapeIterator( int                     shapeID,
                                        size_t                  nbElemsToReturn,
                                        const SMDS_MeshElement* sm1stElem )
 {
-  int iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0;
+  smIdType iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0;
   typedef _ChunkIterator< ElemIterator, TSubIDRangeSet > TChuckIterator;
   return boost::make_shared< TChuckIterator >( myChunks,
                                                & SMDS_ElementChunk::GetSubIDRangesMinMax,
index eb5daee..36edba3 100644 (file)
@@ -59,8 +59,7 @@ SMDS_ElementHolder::~SMDS_ElementHolder()
 
 void SMDS_ElementHolder::beforeCompacting()
 {
-  int i = 0;
-  for ( SMDS_ElemIteratorPtr it = getElements(); it->more(); ++i )
+  for ( SMDS_ElemIteratorPtr it = getElements(); it->more(); )
   {
     const SMDS_MeshElement* e = it->next();
     if ( !e ) continue;
@@ -74,7 +73,7 @@ void SMDS_ElementHolder::beforeCompacting()
     else
     {
       myExternalElems.push_back( e );
-      myVtkIDs.push_back( -1 * (int)myExternalElems.size() );
+      myVtkIDs.push_back( -1 * (vtkIdType) myExternalElems.size() );
     }
   }
 }
@@ -84,8 +83,8 @@ void SMDS_ElementHolder::beforeCompacting()
 //purpose  : restore pointers to elements
 //=======================================================================
 
-void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNew,
-                                          const std::vector<int>& idCellsOldToNew )
+void SMDS_ElementHolder::restoreElements( const std::vector<smIdType>& idNodesOldToNew,
+                                          const std::vector<smIdType>& idCellsOldToNew )
 {
   tmpClear();
 
@@ -94,21 +93,21 @@ void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNe
   std::vector< bool >::iterator isNode = myIsNode.begin();
   for ( size_t i = 0; i < myVtkIDs.size(); ++i, ++isNode )
   {
-    int vtkID = myVtkIDs[i];
+    vtkIdType vtkID = myVtkIDs[i];
     if ( vtkID < 0 )
     {
       elem = myExternalElems[ (-vtkID)-1 ];
     }
     else if ( *isNode )
     {
-      if ( vtkID < (int)idNodesOldToNew.size() )
+      if ( vtkID < (vtkIdType)idNodesOldToNew.size() )
         elem = myMesh->FindNodeVtk( idNodesOldToNew[ vtkID ]);
       else
         elem = myMesh->FindNodeVtk( vtkID );
     }
     else
     {
-      if ( vtkID < (int)idCellsOldToNew.size() )
+      if ( vtkID < (vtkIdType)idCellsOldToNew.size() )
         elem = myMesh->FindElementVtk( idCellsOldToNew[ vtkID ]);
       else
         elem = myMesh->FindElementVtk( vtkID );
index 024bd8f..a5ab4d8 100644 (file)
@@ -29,6 +29,9 @@
 
 #include "SMDS_ElemIterator.hxx"
 
+#include <smIdType.hxx>
+#include <vtkType.h>
+
 #include <vector>
 #include <set>
 
@@ -80,12 +83,12 @@ class SMDS_EXPORT SMDS_ElementHolder
   void beforeCompacting();
 
   //! restore pointers to elements
-  void restoreElements( const std::vector<int>& idNodessOldToNew,
-                        const std::vector<int>& idCellsOldToNew );
+  void restoreElements( const std::vector<smIdType>& idNodessOldToNew,
+                        const std::vector<smIdType>& idCellsOldToNew );
 
 
   std::vector<const SMDS_MeshElement*>      myExternalElems; //!< elements not contained in the mesh
-  std::vector< int >                        myVtkIDs;        //!< vtk IDs of elements
+  std::vector< vtkIdType >                  myVtkIDs;        //!< vtk IDs of elements
   std::vector< bool >                       myIsNode;
   std::set< SMDS_ElementHolder* >::iterator myPtrInMesh;
 };
index dab7192..b01e7c9 100644 (file)
@@ -183,7 +183,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
 ///@param ID : The ID of the MeshNode to create
 ///@return : The created node or NULL if a node with this ID already exists
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, int ID )
+SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, smIdType ID )
 {
   // find the MeshNode corresponding to ID
   SMDS_MeshNode *node = myNodeFactory->NewNode( ID );
@@ -201,7 +201,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, int ID )
 /// create a Mesh0DElement and add it to the current Mesh
 /// @return : The created Mesh0DElement
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID)
+SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(smIdType idnode, smIdType ID)
 {
   const SMDS_MeshNode * node = myNodeFactory->FindNode(idnode);
   if (!node) return NULL;
@@ -224,7 +224,7 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
 /// @return The created 0D element or NULL if an element with this
 ///         ID already exists or if input node is not found.
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int ID)
+SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, smIdType ID)
 {
   if (!n) return 0;
 
@@ -244,7 +244,7 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int I
 /// create a Ball and add it to the current Mesh
 /// @return : The created Ball
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_BallElement* SMDS_Mesh::AddBallWithID( int idnode, double diameter, int ID )
+SMDS_BallElement* SMDS_Mesh::AddBallWithID( smIdType idnode, double diameter, smIdType ID )
 {
   const SMDS_MeshNode * node = myNodeFactory->FindNode( idnode );
   if (!node) return NULL;
@@ -268,7 +268,7 @@ SMDS_BallElement* SMDS_Mesh::AddBall(const SMDS_MeshNode * node, double diameter
 /// @return The created 0D element or NULL if an element with this
 ///         ID already exists or if input node is not found.
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID)
+SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID)
 {
   if (!n) return 0;
 
@@ -288,7 +288,7 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame
 /// @return : The created MeshEdge
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
+SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(smIdType idnode1, smIdType idnode2, smIdType ID)
 {
   const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1);
   const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2);
@@ -318,7 +318,7 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
 
 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
                                         const SMDS_MeshNode * n2,
-                                        int                   ID)
+                                        smIdType              ID)
 {
   if ( !n1 || !n2 ) return 0;
 
@@ -347,7 +347,10 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 /// Add a triangle defined by its nodes IDs
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType idnode1,
+                                        smIdType idnode2,
+                                        smIdType idnode3,
+                                        smIdType ID)
 {
   const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1);
   const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2);
@@ -363,7 +366,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, i
 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                         const SMDS_MeshNode * n2,
                                         const SMDS_MeshNode * n3,
-                                        int ID)
+                                        smIdType ID)
 {
   if ( !n1 || !n2 || !n3 ) return 0;
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -394,11 +397,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 /// Add a quadrangle defined by its nodes IDs
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1,
-                                        int idnode2,
-                                        int idnode3,
-                                        int idnode4,
-                                        int ID)
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType idnode1,
+                                        smIdType idnode2,
+                                        smIdType idnode3,
+                                        smIdType idnode4,
+                                        smIdType ID)
 {
   const SMDS_MeshNode *node1, *node2, *node3, *node4;
   node1 = myNodeFactory->FindNode(idnode1);
@@ -417,7 +420,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                         const SMDS_MeshNode * n2,
                                         const SMDS_MeshNode * n3,
                                         const SMDS_MeshNode * n4,
-                                        int ID)
+                                        smIdType ID)
 {
   if ( !n1 || !n2 || !n3 || !n4 ) return 0;
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -451,11 +454,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 ///or if input nodes are not found.
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
-                                             int idnode2,
-                                             int idnode3,
-                                             int idnode4,
-                                             int ID)
+SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
+                                             smIdType idnode2,
+                                             smIdType idnode3,
+                                             smIdType idnode4,
+                                             smIdType ID)
 {
   const SMDS_MeshNode *node1, *node2, *node3, *node4;
   node1 = myNodeFactory->FindNode(idnode1);
@@ -476,7 +479,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n2,
                                             const SMDS_MeshNode * n3,
                                             const SMDS_MeshNode * n4,
-                                            int ID)
+                                            smIdType ID)
 {
   if ( !n1 || !n2 || !n3 || !n4 ) return 0;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -513,12 +516,12 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 ///or if input nodes are not found.
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
-                                             int idnode2,
-                                             int idnode3,
-                                             int idnode4,
-                                             int idnode5,
-                                             int ID)
+SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
+                                             smIdType idnode2,
+                                             smIdType idnode3,
+