fix after review. Build completed

src/DriverCGNS/DriverCGNS_Read.cxx

@@ -892,7 +892,7 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
               //                      ...
               //                      NfacesM, Face1M, Face2M, ... FaceNM
               const int nbFaces = elemData[ pos++ ];
-              vector<int> quantities( nbFaces );
+              vector<smIdType> quantities( nbFaces );
               vector<const SMDS_MeshNode*> nodes, faceNodes;
               nodes.reserve( nbFaces * 4 );
               for ( int iF = 0; iF < nbFaces; ++iF )

src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx

@@ -139,7 +139,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
 
       if (( v = myMesh->DownCast< SMDS_MeshVolume >( elem )))
       {
-        std::vector<int> quant = v->GetQuantities();
+        std::vector<smIdType> quant = v->GetQuantities();
         if ( !quant.empty() )
         {
           fprintf(aFileId, "%d %d ", (int)quant.size(), quant[0]);

src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx

@@ -400,7 +400,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
             for(TInt iElem = 0; iElem < aNbElem; iElem++){
               MED::TCConnSliceArr aConnSliceArr = aPolyedreInfo->GetConnSliceArr(iElem);
               TInt aNbFaces = aConnSliceArr.size();
-              typedef MED::TVector<int> TQuantities;
+              typedef MED::TVector<smIdType> TQuantities;
               TQuantities aQuantities(aNbFaces);
               TInt aNbNodes = aPolyedreInfo->GetNbNodes(iElem);
               TNodeIds aNodeIds(aNbNodes);

src/SMDS/SMDS_ElementFactory.cxx

@@ -383,9 +383,9 @@ void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
   // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
   // theVtkIDsOldToNew[ old VtkID ] = new VtkID
 
-  int  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
+  smIdType  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
-  int  newNbNodes = NbUsedElements();
+  smIdType  newNbNodes = NbUsedElements();
-  int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
+  smIdType newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
   smIdType   maxNodeID = GetMaxID();
 
   theVtkIDsOldToNew.resize( oldNbNodes, -1 );

src/SMDS/SMDS_ElementFactory.hxx

@@ -98,7 +98,7 @@ public:
   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

src/SMDS/SMDS_Mesh.cxx

@@ -908,7 +908,7 @@ SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_Mes
 ///////////////////////////////////////////////////////////////////////////////
 
 SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType> & nodes_ids,
-                                                        const std::vector<int> & quantities,
+                                                        const std::vector<smIdType> & quantities,
                                                         const smIdType                ID)
 {
   int nbNodes = nodes_ids.size();
@@ -928,7 +928,7 @@ SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdTy
 
 SMDS_MeshVolume*
 SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                      const std::vector<int>                 & quantities,
+                                      const std::vector<smIdType>            & quantities,
                                       const smIdType                           ID)
 {
   if ( nodes.empty() || quantities.empty() )
@@ -952,7 +952,7 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<const SMDS_MeshNode*>& n
 
 SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
 (const std::vector<const SMDS_MeshNode*> & nodes,
- const std::vector<int>                  & quantities)
+ const std::vector<smIdType>             & quantities)
 {
   smIdType ID = myCellFactory->GetFreeID();
   return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
@@ -1459,7 +1459,7 @@ int SMDS_Mesh::GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& node
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the number of nodes
 ///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbNodes() const
+smIdType SMDS_Mesh::NbNodes() const
 {
   return myInfo.NbNodes();
 }
@@ -1474,7 +1474,7 @@ int SMDS_Mesh::NbElements() const
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the number of 0D elements
 ///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::Nb0DElements() const
+smIdType SMDS_Mesh::Nb0DElements() const
 {
   return myInfo.Nb0DElements();
 }
@@ -1589,7 +1589,7 @@ SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator() const
 
 SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const
 {
-  int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
+  smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
   return myCellFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::GeomFilter( type ),
                                                           nbElems);
 }
@@ -1600,7 +1600,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) c
   {
     return myNodeFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::NonNullFilter );
   }
-  int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
+  smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
   return myCellFactory->GetIterator<SMDS_ElemIterator>( new SMDS_MeshElement::EntityFilter( type ),
                                                         nbElems);
 }
@@ -1620,7 +1620,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
     return myNodeFactory->GetIterator< TIterator >( new SMDS_MeshElement::NonNullFilter );
 
   default:
-    int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
+    smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
     return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( type ),
                                                     nbElems);
   }
@@ -1634,7 +1634,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
 SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
 {
   typedef SMDS_EdgeIterator TIterator;
-  int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbEdges();
+  smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbEdges();
   return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Edge ),
                                                   nbElems);
 }
@@ -1646,7 +1646,7 @@ SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
 SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
 {
   typedef SMDS_FaceIterator TIterator;
-  int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbFaces();
+  smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbFaces();
   return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Face ),
                                                   nbElems);
 }
@@ -1658,7 +1658,7 @@ SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
 SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const
 {
   typedef SMDS_VolumeIterator TIterator;
-  int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbVolumes();
+  smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbVolumes();
   return
     myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Volume ),
                                              nbElems );
@@ -2981,8 +2981,8 @@ void SMDS_Mesh::CompactMesh()
   myCellFactory->Compact( idCellsNewToOld );
 
   // make VTK IDs correspond to SMDS IDs
-  int newNodeSize = myNodeFactory->NbUsedElements();
+  smIdType newNodeSize = myNodeFactory->NbUsedElements();
-  int newCellSize = myCellFactory->NbUsedElements();
+  smIdType newCellSize = myCellFactory->NbUsedElements();
   myGrid->compactGrid( idNodesOldToNew, newNodeSize, idCellsNewToOld, newCellSize );
 
   if ( idsChange && !myElemHolders.empty() )

src/SMDS/SMDS_Mesh.hxx

@@ -575,17 +575,17 @@ public:
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
     (const std::vector<smIdType> & nodes_ids,
-     const std::vector<int> & quantities,
+     const std::vector<smIdType> & quantities,
      const smIdType                ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
     (const std::vector<const SMDS_MeshNode*> & nodes,
-     const std::vector<int>                  & quantities,
+     const std::vector<smIdType>             & quantities,
-     const smIdType                                 ID);
+     const smIdType                            ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolume
     (const std::vector<const SMDS_MeshNode*> & nodes,
-     const std::vector<int>                  & quantities);
+     const std::vector<smIdType>             & quantities);
 
   virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
 
@@ -689,9 +689,9 @@ public:
 
   const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
 
-  virtual int NbNodes() const;
+  virtual smIdType NbNodes() const;
   virtual int NbElements() const;
-  virtual int Nb0DElements() const;
+  virtual smIdType Nb0DElements() const;
   virtual int NbBalls() const;
   virtual int NbEdges() const;
   virtual int NbFaces() const;

src/SMDS/SMDS_MeshVolume.cxx

@@ -36,7 +36,7 @@
 
 // init a polyherdon
 void SMDS_MeshVolume::init( const std::vector<const SMDS_MeshNode*>& nodes,
-                            const std::vector<int>&                  nbNodesPerFace )
+                            const std::vector<smIdType>&             nbNodesPerFace )
 {
   std::vector<vtkIdType> ptIds;
   ptIds.reserve( nodes.size() + nbNodesPerFace.size() + 1 );
@@ -44,9 +44,9 @@ void SMDS_MeshVolume::init( const std::vector<const SMDS_MeshNode*>& nodes,
   size_t nbFaces = nbNodesPerFace.size();
   for ( size_t iN = 0, iF = 0; iF < nbFaces; iF++ )
   {
-    int nf = nbNodesPerFace[iF];
+    smIdType nf = nbNodesPerFace[iF];
     ptIds.push_back(nf);
-    for (int n = 0; n < nf; n++)
+    for (smIdType n = 0; n < nf; n++)
       ptIds.push_back( nodes[ iN++ ]->GetVtkID() );
   }
 
@@ -115,7 +115,7 @@ bool SMDS_MeshVolume::ChangeNodes(const std::vector<const SMDS_MeshNode*>& nodes
   return true;
 }
 
-const SMDS_MeshNode* SMDS_MeshVolume::GetNode(const int ind) const
+const SMDS_MeshNode* SMDS_MeshVolume::GetNode(const smIdType ind) const
 {
   if ( !IsPoly() )
     return SMDS_MeshCell::GetNode( ind );
@@ -266,18 +266,18 @@ const SMDS_MeshNode* SMDS_MeshVolume::GetFaceNode (const int face_ind, const int
   return 0;
 }
 
-std::vector<int> SMDS_MeshVolume::GetQuantities() const
+std::vector<smIdType> SMDS_MeshVolume::GetQuantities() const
 {
-  std::vector<int> quantities;
+  std::vector<smIdType> quantities;
   if ( IsPoly() )
   {
     vtkIdType nFaces = 0;
     vtkIdType const *ptIds(nullptr);
     getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
-    int id = 0;
+    smIdType id = 0;
-    for (int i = 0; i < nFaces; i++)
+    for (smIdType i = 0; i < nFaces; i++)
     {
-      int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
+      smIdType nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
       quantities.push_back( nodesInFace );
       id += (nodesInFace + 1);
     }

src/SMDS/SMDS_MeshVolume.hxx

@@ -31,6 +31,8 @@
 
 #include "SMDS_MeshCell.hxx"
 
+#include <smIdType.hxx>
+
 /*!
  * \brief Mesh volume. This type is not allocated.
  *        It is only used as function argument type to provide more clear semantic
@@ -39,7 +41,7 @@
 class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
 {
   void init( const std::vector<const SMDS_MeshNode*>& nodes,
-             const std::vector<int>&                  nbNodesPerFace ); // init a polyherdon
+             const std::vector<smIdType>&             nbNodesPerFace ); // init a polyherdon
 
   void init( const std::vector<vtkIdType>& vtkNodeIds );
 
@@ -47,7 +49,7 @@ class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
 
  public:
   virtual SMDSAbs_ElementType  GetType() const { return SMDSAbs_Volume; }
-  virtual const SMDS_MeshNode* GetNode(const int ind) const;
+  virtual const SMDS_MeshNode* GetNode(const smIdType ind) const;
   virtual int  NbNodes() const;
   virtual int  NbFaces() const;
   virtual int  NbEdges() const;
@@ -69,7 +71,7 @@ class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
   // 1 <= node_ind <= NbFaceNodes()
   const SMDS_MeshNode* GetFaceNode (const int face_ind, const int node_ind) const;
 
-  std::vector<int> GetQuantities() const;
+  std::vector<smIdType> GetQuantities() const;
 
   static SMDSAbs_ElementType Type() { return SMDSAbs_Volume; }
 };

src/SMDS/SMDS_VolumeTool.cxx

@@ -1983,49 +1983,49 @@ bool SMDS_VolumeTool::setFace( int faceIndex ) const
         myAllFacesNodeIndices_F  = &Tetra_F [0][0];
         //myAllFacesNodeIndices_FE = &Tetra_F [0][0];
         myAllFacesNodeIndices_RE = &Tetra_RE[0][0];
-        myAllFacesNbNodes        = Tetra_nbN;
+        myAllFacesNbNodes        = (smIdType*)(Tetra_nbN);
         myMaxFaceNbNodes         = sizeof(Tetra_F[0])/sizeof(Tetra_F[0][0]);
         break;
       case 5:
         myAllFacesNodeIndices_F  = &Pyramid_F [0][0];
         //myAllFacesNodeIndices_FE = &Pyramid_F [0][0];
         myAllFacesNodeIndices_RE = &Pyramid_RE[0][0];
-        myAllFacesNbNodes        = Pyramid_nbN;
+        myAllFacesNbNodes        = (smIdType*)(Pyramid_nbN);
         myMaxFaceNbNodes         = sizeof(Pyramid_F[0])/sizeof(Pyramid_F[0][0]);
         break;
       case 6:
         myAllFacesNodeIndices_F  = &Penta_F [0][0];
         //myAllFacesNodeIndices_FE = &Penta_FE[0][0];
         myAllFacesNodeIndices_RE = &Penta_RE[0][0];
-        myAllFacesNbNodes        = Penta_nbN;
+        myAllFacesNbNodes        = (smIdType*)(Penta_nbN);
         myMaxFaceNbNodes         = sizeof(Penta_F[0])/sizeof(Penta_F[0][0]);
         break;
       case 8:
         myAllFacesNodeIndices_F  = &Hexa_F [0][0];
         ///myAllFacesNodeIndices_FE = &Hexa_FE[0][0];
         myAllFacesNodeIndices_RE = &Hexa_RE[0][0];
-        myAllFacesNbNodes        = Hexa_nbN;
+        myAllFacesNbNodes        = (smIdType*)(Hexa_nbN);
         myMaxFaceNbNodes         = sizeof(Hexa_F[0])/sizeof(Hexa_F[0][0]);
         break;
       case 10:
         myAllFacesNodeIndices_F  = &QuadTetra_F [0][0];
         //myAllFacesNodeIndices_FE = &QuadTetra_F [0][0];
         myAllFacesNodeIndices_RE = &QuadTetra_RE[0][0];
-        myAllFacesNbNodes        = QuadTetra_nbN;
+        myAllFacesNbNodes        = (smIdType*)(QuadTetra_nbN);
         myMaxFaceNbNodes         = sizeof(QuadTetra_F[0])/sizeof(QuadTetra_F[0][0]);
         break;
       case 13:
         myAllFacesNodeIndices_F  = &QuadPyram_F [0][0];
         //myAllFacesNodeIndices_FE = &QuadPyram_F [0][0];
         myAllFacesNodeIndices_RE = &QuadPyram_RE[0][0];
-        myAllFacesNbNodes        = QuadPyram_nbN;
+        myAllFacesNbNodes        = (smIdType*)(QuadPyram_nbN);
         myMaxFaceNbNodes         = sizeof(QuadPyram_F[0])/sizeof(QuadPyram_F[0][0]);
         break;
       case 15:
         myAllFacesNodeIndices_F  = &QuadPenta_F [0][0];
         //myAllFacesNodeIndices_FE = &QuadPenta_FE[0][0];
         myAllFacesNodeIndices_RE = &QuadPenta_RE[0][0];
-        myAllFacesNbNodes        = QuadPenta_nbN;
+        myAllFacesNbNodes        = (smIdType*)(QuadPenta_nbN);
         myMaxFaceNbNodes         = sizeof(QuadPenta_F[0])/sizeof(QuadPenta_F[0][0]);
         break;
       case 20:
@@ -2033,14 +2033,14 @@ bool SMDS_VolumeTool::setFace( int faceIndex ) const
         myAllFacesNodeIndices_F  = &QuadHexa_F [0][0];
         //myAllFacesNodeIndices_FE = &QuadHexa_FE[0][0];
         myAllFacesNodeIndices_RE = &QuadHexa_RE[0][0];
-        myAllFacesNbNodes        = QuadHexa_nbN;
+        myAllFacesNbNodes        = (smIdType*)(QuadHexa_nbN);
         myMaxFaceNbNodes         = sizeof(QuadHexa_F[0])/sizeof(QuadHexa_F[0][0]);
         if ( !myIgnoreCentralNodes && myVolumeNodes.size() == 27 )
         {
           myAllFacesNodeIndices_F  = &TriQuadHexa_F [0][0];
           //myAllFacesNodeIndices_FE = &TriQuadHexa_FE[0][0];
           myAllFacesNodeIndices_RE = &TriQuadHexa_RE[0][0];
-          myAllFacesNbNodes        = TriQuadHexa_nbN;
+          myAllFacesNbNodes        = (smIdType*)(TriQuadHexa_nbN);
           myMaxFaceNbNodes         = sizeof(TriQuadHexa_F[0])/sizeof(TriQuadHexa_F[0][0]);
         }
         break;
@@ -2048,7 +2048,7 @@ bool SMDS_VolumeTool::setFace( int faceIndex ) const
         myAllFacesNodeIndices_F  = &HexPrism_F [0][0];
         //myAllFacesNodeIndices_FE = &HexPrism_FE[0][0];
         myAllFacesNodeIndices_RE = &HexPrism_RE[0][0];
-        myAllFacesNbNodes        = HexPrism_nbN;
+        myAllFacesNbNodes        = (smIdType*)(HexPrism_nbN);
         myMaxFaceNbNodes         = sizeof(HexPrism_F[0])/sizeof(HexPrism_F[0][0]);
         break;
       default:

src/SMDS/SMDS_VolumeTool.hxx

@@ -31,6 +31,8 @@
 
 #include "SMESH_SMDS.hxx"
 
+#include <smIdType.hxx>
+
 class SMDS_MeshElement;
 class SMDS_MeshNode;
 class SMDS_MeshVolume;
@@ -261,7 +263,7 @@ class SMDS_EXPORT SMDS_VolumeTool
   int                     myNbFaces;
   std::vector<const SMDS_MeshNode*> myVolumeNodes;
   std::vector< int >      myPolyIndices; // of a myCurFace
-  std::vector< int >      myPolyQuantities;
+  std::vector<smIdType>   myPolyQuantities;
   std::vector< int >      myPolyFacetOri; // -1-in, +1-out, 0-undef
 
   typedef std::pair<int,int> Link;
@@ -271,7 +273,7 @@ class SMDS_EXPORT SMDS_VolumeTool
 
   mutable const int*      myAllFacesNodeIndices_F;
   mutable const int*      myAllFacesNodeIndices_RE;
-  mutable const int*      myAllFacesNbNodes;
+  mutable const smIdType* myAllFacesNbNodes;
   mutable int             myMaxFaceNbNodes;
 
   struct SaveFacet;

src/SMESH/SMESH_MeshEditor.cxx

@@ -3121,7 +3121,7 @@ public:
     :myMesh( theMesh ), myMaxID( theMesh->MaxNodeID() + 1)
   {}
 
-  long GetLinkID (const SMDS_MeshNode * n1,
+  smIdType GetLinkID (const SMDS_MeshNode * n1,
                   const SMDS_MeshNode * n2) const
   {
     return ( Min(FromIdType<int>(n1->GetID()),FromIdType<int>(n2->GetID())) * myMaxID + Max(FromIdType<int>(n1->GetID()),FromIdType<int>(n2->GetID())));
@@ -4603,7 +4603,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
         baseType = SMDSEntity_Polygon; // WARNING: change baseType !!!!
       }
       vector<const SMDS_MeshNode*> polyedre_nodes (nbNodes*2 + 4*nbNodes);
-      vector<int> quantities (nbNodes + 2);
+      vector<smIdType> quantities (nbNodes + 2);
       polyedre_nodes.clear();
       quantities.clear();
 
@@ -6774,7 +6774,7 @@ void SMESH_MeshEditor::FindCoincidentNodes (TIDSortedNodeSet &   theNodes,
 
 int SMESH_MeshEditor::SimplifyFace (const vector<const SMDS_MeshNode *>& faceNodes,
                                     vector<const SMDS_MeshNode *>&       poly_nodes,
-                                    vector<int>&                         quantities) const
+                                    vector<smIdType>&                    quantities) const
 {
   int nbNodes = faceNodes.size();
   while ( faceNodes[ 0 ] == faceNodes[ nbNodes-1 ] && nbNodes > 2 )
@@ -7078,7 +7078,7 @@ bool SMESH_MeshEditor::applyMerge( const SMDS_MeshElement* elem,
 
       // a polygon can divide into several elements
       vector<const SMDS_MeshNode *> polygons_nodes;
-      vector<int> quantities;
+      vector<smIdType> quantities;
       nbResElems = SimplifyFace( curNodes, polygons_nodes, quantities );
       newElemDefs.resize( nbResElems );
       for ( int inode = 0, iface = 0; iface < nbResElems; iface++ )
@@ -7118,7 +7118,7 @@ bool SMESH_MeshEditor::applyMerge( const SMDS_MeshElement* elem,
           int nbFaces = aPolyedre->NbFaces();
 
           vector<const SMDS_MeshNode *>& poly_nodes = newElemDefs[0].myNodes;
-          vector<int>                  & quantities = newElemDefs[0].myPolyhedQuantities;
+          vector<smIdType>             & quantities = newElemDefs[0].myPolyhedQuantities;
           vector<const SMDS_MeshNode *>  faceNodes;
           poly_nodes.clear();
           quantities.clear();
@@ -7370,7 +7370,7 @@ bool SMESH_MeshEditor::applyMerge( const SMDS_MeshElement* elem,
         ////////////////// HEXAHEDRON ---> polyhedron
         hexa.SetExternalNormal();
         vector<const SMDS_MeshNode *>& poly_nodes = newElemDefs[0].myNodes;
-        vector<int>                  & quantities = newElemDefs[0].myPolyhedQuantities;
+        vector<smIdType>             & quantities = newElemDefs[0].myPolyhedQuantities;
         poly_nodes.reserve( 6 * 4 ); poly_nodes.clear();
         quantities.reserve( 6 );     quantities.clear();
         for ( int iFace = 0; iFace < 6; iFace++ )
@@ -8607,7 +8607,7 @@ void SMESH_MeshEditor::UpdateVolumes (const SMDS_MeshNode*        theBetweenNode
     // insert new nodes in all faces of the volume, sharing link theBetweenNode1 - theBetweenNode2
     int iface, nbFaces = aVolume.NbFaces();
     vector<const SMDS_MeshNode *> poly_nodes;
-    vector<int> quantities (nbFaces);
+    vector<smIdType> quantities (nbFaces);
 
     for (iface = 0; iface < nbFaces; iface++) {
       int nbFaceNodes = aVolume.NbFaceNodes(iface), nbInserted = 0;
@@ -8672,7 +8672,7 @@ namespace
 
   void volumeToPolyhedron( const SMDS_MeshElement*         elem,
                            vector<const SMDS_MeshNode *> & nodes,
-                           vector<int> &                   nbNodeInFaces )
+                           vector<smIdType> &                   nbNodeInFaces )
   {
     nodes.clear();
     nbNodeInFaces.clear();
@@ -8701,7 +8701,7 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh *   theSm,
   int nbElem = 0;
   if( !theSm ) return nbElem;
 
-  vector<int> nbNodeInFaces;
+  vector<smIdType> nbNodeInFaces;
   vector<const SMDS_MeshNode *> nodes;
   SMDS_ElemIteratorPtr ElemItr = theSm->GetElements();
   while(ElemItr->more())
@@ -8948,7 +8948,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
     }
 
     // convert volumes
-    vector<int> nbNodeInFaces;
+    vector<smIdType> nbNodeInFaces;
     SMDS_VolumeIteratorPtr aVolumeItr = meshDS->volumesIterator();
     while(aVolumeItr->more())
     {

src/SMESH/SMESH_MeshEditor.hxx

@@ -89,7 +89,7 @@ public:
     bool                              myIsPoly, myIsQuad;
     int                               myID;
     double                            myBallDiameter;
-    std::vector<int>                  myPolyhedQuantities;
+    std::vector<smIdType>             myPolyhedQuantities;
     std::vector<const SMDS_MeshNode*> myNodes; // not managed by ElemFeatures
 
     SMESH_EXPORT ElemFeatures( SMDSAbs_ElementType type=SMDSAbs_All, bool isPoly=false, bool isQuad=false )
@@ -103,11 +103,11 @@ public:
     SMESH_EXPORT ElemFeatures& Init( double diameter )
     { myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; }
 
-    SMESH_EXPORT ElemFeatures& Init( std::vector<int>& quanities, bool isQuad=false )
+    SMESH_EXPORT ElemFeatures& Init( std::vector<smIdType>& quanities, bool isQuad=false )
     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities.swap( quanities ); return *this; }
 
-    SMESH_EXPORT ElemFeatures& Init( const std::vector<int>& quanities, bool isQuad=false )
+    SMESH_EXPORT ElemFeatures& Init( const std::vector<smIdType>& quanities, bool isQuad=false )
     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities = quanities; return *this; }
 
@@ -517,7 +517,7 @@ public:
 
   int SimplifyFace (const std::vector<const SMDS_MeshNode *>& faceNodes,
                     std::vector<const SMDS_MeshNode *>&       poly_nodes,
-                    std::vector<int>&                         quantities) const;
+                    std::vector<smIdType>&                    quantities) const;
   // Split face, defined by <faceNodes>, into several faces by repeating nodes.
   // Is used by MergeNodes()
 

src/SMESH/SMESH_MesherHelper.cxx

@@ -2441,7 +2441,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
 
 SMDS_MeshVolume*
 SMESH_MesherHelper::AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
-                                         const std::vector<int>&                  quantities,
+                                         const std::vector<smIdType>&             quantities,
                                          const int                                id,
                                          const bool                               force3d)
 {
@@ -2457,7 +2457,7 @@ SMESH_MesherHelper::AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>
   else
   {
     vector<const SMDS_MeshNode*> newNodes;
-    vector<int> newQuantities;
+    vector<smIdType> newQuantities;
     for ( size_t iFace = 0, iN = 0; iFace < quantities.size(); ++iFace )
     {
       int nbNodesInFace = quantities[iFace];

src/SMESH/SMESH_MesherHelper.hxx

@@ -440,7 +440,7 @@ public:
    * Creates polyhedron. In quadratic mesh, adds medium nodes
    */
   SMDS_MeshVolume* AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
-                                        const std::vector<int>&                  quantities,
+                                        const std::vector<smIdType>&             quantities,
                                         const int                                ID=0,
                                         const bool                               force3d = true);
   /*!

src/SMESH/SMESH_Pattern.cxx

@@ -3732,9 +3732,9 @@ void SMESH_Pattern::
           if ( !volTool.Set( elem ) || !avoidSet.insert( elem ).second )
             continue; // skip faces or refined elements
           // add polyhedron definition
-          myPolyhedronQuantities.push_back(vector<int> ());
+          myPolyhedronQuantities.push_back(vector<smIdType> ());
           myPolyElemXYZIDs.push_back(TElemDef());
-          vector<int>& quantity = myPolyhedronQuantities.back();
+          vector<smIdType>& quantity = myPolyhedronQuantities.back();
           TElemDef &   elemDef  = myPolyElemXYZIDs.back();
           // get definitions of new elements on volume faces
           bool makePoly = false;
@@ -3767,7 +3767,7 @@ bool SMESH_Pattern::
                      const int                             theNbBndNodes,
                      const vector< const SMDS_MeshNode* >& theNodes,
                      list< int >&                          theFaceDefs,
-                     vector<int>&                          theQuantity)
+                     vector<smIdType>&                     theQuantity)
 {
   bool makePoly = false;
 
@@ -4257,7 +4257,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh*                            theMes
   bool is2d = myIs2D;
 
   list< TElemDef >::const_iterator enIt = theElemNodeIDs.begin();
-  list< vector<int> >::iterator quantity = myPolyhedronQuantities.begin();
+  list< vector<smIdType> >::iterator quantity = myPolyhedronQuantities.begin();
   for ( int iElem = 0; enIt != theElemNodeIDs.end(); enIt++, iElem++ )
   {
     const TElemDef & elemNodeInd = *enIt;

src/SMESH/SMESH_Pattern.hxx

@@ -28,6 +28,7 @@
 #define SMESH_Pattern_HeaderFile
 
 #include "SMESH_SMESH.hxx"
+#include <smIdType.hxx>
 
 #include <vector>
 #include <list>
@@ -328,7 +329,7 @@ private:
                           const int                                  theNbBndNodes,
                           const std::vector< const SMDS_MeshNode* >& theNodes,
                           std::list< int >&                          theFaceDefs,
-                          std::vector<int>&                          theQuantity);
+                          std::vector<smIdType>&                     theQuantity);
   // fill faces definition for a volume face defined by theBndNodes
   // return true if a face definition changes
   
@@ -392,7 +393,7 @@ private:
   std::vector<const SMDS_MeshElement*> myPolyElems;
   // definitions of new poly elements
   std::list< TElemDef >                myPolyElemXYZIDs;
-  std::list< std::vector<int> >        myPolyhedronQuantities;
+  std::list< std::vector<smIdType> >   myPolyhedronQuantities;
 
   // map a boundary to XYZs on it;
   // a boundary (edge or face) is defined as a set of its nodes,

src/SMESHClient/SMESH_Client.cxx

@@ -424,7 +424,7 @@ namespace
       }
 
       int aNbFaces = anIndexes[anIndexId++];
-      std::vector<int> quantities (aNbFaces);
+      std::vector<smIdType> quantities (aNbFaces);
       for (int i = 0; i < aNbFaces; i++) {
         quantities[i] = anIndexes[anIndexId++];
       }

src/SMESHDS/SMESHDS_Command.cxx

@@ -160,8 +160,8 @@ void SMESHDS_Command::AddFace(int NewFaceID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID,
+void SMESHDS_Command::AddVolume(smIdType NewVolID,
-        int idnode1, int idnode2, int idnode3, int idnode4)
+        smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4)
 {
         if ( myType != SMESHDS_AddTetrahedron)
         {
@@ -180,8 +180,8 @@ void SMESHDS_Command::AddVolume(int NewVolID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID,
+void SMESHDS_Command::AddVolume(smIdType NewVolID,
-        int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
+        smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4, smIdType idnode5)
 {
         if ( myType != SMESHDS_AddPyramid)
         {
@@ -201,9 +201,9 @@ void SMESHDS_Command::AddVolume(int NewVolID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID,
+void SMESHDS_Command::AddVolume(smIdType NewVolID,
-        int idnode1,
+        smIdType idnode1,
-        int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
+        smIdType idnode2, smIdType idnode3, smIdType idnode4, smIdType idnode5, smIdType idnode6)
 {
         if ( myType != SMESHDS_AddPrism)
         {
@@ -224,11 +224,11 @@ void SMESHDS_Command::AddVolume(int NewVolID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID,
+void SMESHDS_Command::AddVolume(smIdType NewVolID,
-        int idnode1,
+        smIdType idnode1,
-        int idnode2,
+        smIdType idnode2,
-        int idnode3,
+        smIdType idnode3,
-        int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
+        smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8)
 {
         if ( myType != SMESHDS_AddHexahedron)
         {
@@ -247,10 +247,10 @@ void SMESHDS_Command::AddVolume(int NewVolID,
         myNumber++;
 }
 
-void SMESHDS_Command::AddVolume(int NewVolID,
+void SMESHDS_Command::AddVolume(smIdType NewVolID,
-                                int idnode1,int idnode2,int idnode3,int idnode4,
+                                smIdType idnode1,smIdType idnode2,smIdType idnode3,smIdType idnode4,
-                                int idnode5, int idnode6, int idnode7, int idnode8,
+                                smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
-                                int idnode9, int idnode10, int idnode11, int idnode12)
+                                smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12)
 {
   if (myType != SMESHDS_AddHexagonalPrism)
   {
@@ -323,7 +323,7 @@ void SMESHDS_Command::AddQuadPolygonalFace (const smIdType               Element
 //=======================================================================
 void SMESHDS_Command::AddPolyhedralVolume (const smIdType               ElementID,
                                            const std::vector<smIdType>& nodes_ids,
-                                           const std::vector<int>&      quantities)
+                                           const std::vector<smIdType>& quantities)
 {
   if ( myType != SMESHDS_AddPolyhedron) {
     MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");

src/SMESHDS/SMESHDS_Command.hxx

@@ -45,24 +45,24 @@ class SMESHDS_EXPORT SMESHDS_Command
         void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
         void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,
                      int idnode4);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4);
+                       smIdType idnode4);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4, int idnode5);
+                       smIdType idnode4, smIdType idnode5);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4, int idnode5, int idnode6);
+                       smIdType idnode4, smIdType idnode5, smIdType idnode6);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4, int idnode5, int idnode6, int idnode7, int idnode8);
+                       smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
+                       smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
-                       int idnode9, int idnode10, int idnode11, int idnode12);
+                       smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12);
         void AddPolygonalFace (const smIdType               ElementID,
                                const std::vector<smIdType>& nodes_ids);
         void AddQuadPolygonalFace (const smIdType               ElementID,
                                    const std::vector<smIdType>& nodes_ids);
         void AddPolyhedralVolume (const smIdType               ElementID,
                                   const std::vector<smIdType>& nodes_ids,
-                                  const std::vector<int>& quantities);
+                                  const std::vector<smIdType>& quantities);
         void AddBall(int NewBallID, int node, double diameter);
         // special methods for quadratic elements
         void AddEdge(int NewEdgeID, int n1, int n2, int n12);

src/SMESHDS/SMESHDS_Mesh.cxx

@@ -790,7 +790,7 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
 //purpose  : 
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
-                                                          const std::vector<int>& quantities,
+                                                          const std::vector<smIdType>& quantities,
                                                           const smIdType               ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
@@ -802,8 +802,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smId
 
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
 (const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<int>&                  quantities,
+ const std::vector<smIdType>&             quantities,
- const smIdType                                ID)
+ const smIdType                           ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
   if (anElem) {
@@ -819,7 +819,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
 
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 (const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<int>&                  quantities)
+ const std::vector<smIdType>&             quantities)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
   if (anElem) {

src/SMESHDS/SMESHDS_Mesh.hxx

@@ -567,17 +567,17 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
     (const std::vector<smIdType>& nodes_ids,
-     const std::vector<int>& quantities,
+     const std::vector<smIdType>& quantities,
      const smIdType               ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
     (const std::vector<const SMDS_MeshNode*>& nodes,
-     const std::vector<int>&                  quantities,
+     const std::vector<smIdType>&             quantities,
-     const smIdType                                ID);
+     const smIdType                           ID);
 
   virtual SMDS_MeshVolume* AddPolyhedralVolume
     (const std::vector<const SMDS_MeshNode*>& nodes,
-     const std::vector<int>&                  quantities);
+     const std::vector<smIdType>&             quantities);
 
   virtual void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
   virtual void RemoveNode(const SMDS_MeshNode *);

src/SMESHDS/SMESHDS_Script.cxx

@@ -160,9 +160,9 @@ void SMESHDS_Script::AddFace(int NewFaceID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Script::AddVolume(int NewID,
+void SMESHDS_Script::AddVolume(smIdType NewID,
-                               int idnode1, int idnode2,
+                               smIdType idnode1, smIdType idnode2,
-                               int idnode3, int idnode4)
+                               smIdType idnode3, smIdType idnode4)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;
@@ -177,9 +177,9 @@ void SMESHDS_Script::AddVolume(int NewID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Script::AddVolume(int NewID,
+void SMESHDS_Script::AddVolume(smIdType NewID,
-                               int idnode1, int idnode2,
+                               smIdType idnode1, smIdType idnode2,
-                               int idnode3, int idnode4, int idnode5)
+                               smIdType idnode3, smIdType idnode4, smIdType idnode5)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;
@@ -194,9 +194,9 @@ void SMESHDS_Script::AddVolume(int NewID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Script::AddVolume(int NewID,
+void SMESHDS_Script::AddVolume(smIdType NewID,
-                               int idnode1, int idnode2, int idnode3,
+                               smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                               int idnode4, int idnode5, int idnode6)
+                               smIdType idnode4, smIdType idnode5, smIdType idnode6)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;
@@ -211,9 +211,9 @@ void SMESHDS_Script::AddVolume(int NewID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Script::AddVolume(int NewID,
+void SMESHDS_Script::AddVolume(smIdType NewID,
-                               int idnode1, int idnode2, int idnode3, int idnode4,
+                               smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4,
-                               int idnode5, int idnode6, int idnode7, int idnode8)
+                               smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;
@@ -228,9 +228,9 @@ void SMESHDS_Script::AddVolume(int NewID,
 //function : 
 //purpose  : 
 //=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+void SMESHDS_Script::AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                               int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
+                               smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
-                               int idnode9, int idnode10, int idnode11, int idnode12)
+                               smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;
@@ -274,7 +274,7 @@ void SMESHDS_Script::AddQuadPolygonalFace(smIdType NewFaceID, const std::vector<
 //=======================================================================
 void SMESHDS_Script::AddPolyhedralVolume (smIdType                     NewID,
                                           const std::vector<smIdType>& nodes_ids,
-                                          const std::vector<int>&      quantities)
+                                          const std::vector<smIdType>& quantities)
 {
   if(myIsEmbeddedMode){
     myIsModified = true;

src/SMESHDS/SMESHDS_Script.hxx

@@ -52,17 +52,17 @@ class SMESHDS_EXPORT SMESHDS_Script
         void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
         void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,
                 int idnode4);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                int idnode4);
+                smIdType idnode4);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                int idnode4, int idnode5);
+                smIdType idnode4, smIdType idnode5);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                int idnode4, int idnode5, int idnode6);
+                smIdType idnode4, smIdType idnode5, smIdType idnode6);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                int idnode4, int idnode5, int idnode6, int idnode7, int idnode8);
+                smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8);
-        void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
+        void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
-                       int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
+                       smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
-                       int idnode9, int idnode10, int idnode11, int idnode12);
+                       smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12);
 
         void AddPolygonalFace (const smIdType               NewFaceID,
                                const std::vector<smIdType>& nodes_ids);
@@ -70,7 +70,7 @@ class SMESHDS_EXPORT SMESHDS_Script
                                         const std::vector<smIdType>& nodes_ids);
         void AddPolyhedralVolume (const smIdType               NewVolID,
                                   const std::vector<smIdType>& nodes_ids,
-                                  const std::vector<int>& quantities);
+                                  const std::vector<smIdType>& quantities);
         void AddBall(int NewBallID, int node, double diameter);
 
         // special methods for quadratic elements

src/SMESHUtils/SMESH_Offset.cxx

@@ -277,7 +277,7 @@ namespace
 
     static Standard_Integer HashCode(const CutFace& f, const Standard_Integer upper)
     {
-      return ::HashCode( (int)(f.myInitFace->GetID()), upper );
+      return ::HashCode( FromIdType<int>(f.myInitFace->GetID()), upper );
     }
     static Standard_Boolean IsEqual(const CutFace& f1, const CutFace& f2 )
     {

src/SMESH_I/SMESH_MeshEditor_i.cxx

@@ -1190,7 +1190,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I
     }
 
   int NbFaces = Quantities.length();
-  std::vector<int> q (NbFaces);
+  std::vector<smIdType> q (NbFaces);
   for (int j = 0; j < NbFaces; j++)
     q[j] = Quantities[j];
 
@@ -1220,7 +1220,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_ar
 
   int NbFaces = IdsOfFaces.length();
   std::vector<const SMDS_MeshNode*> poly_nodes;
-  std::vector<int> quantities (NbFaces);
+  std::vector<smIdType> quantities (NbFaces);
 
   for (int i = 0; i < NbFaces; i++) {
     const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);

src/StdMeshers/StdMeshers_Cartesian_3D.cxx

@@ -818,7 +818,7 @@ namespace
       };
 
       vector< _nodeDef >      _nodes;
-      vector< int >           _quantities;
+      vector< smIdType >      _quantities;
       _volumeDef*             _next; // to store several _volumeDefs in a chain
       TGeomID                 _solidID;
       const SMDS_MeshElement* _volume; // new volume
@@ -5257,7 +5257,7 @@ namespace
         if ( loopsJoined )
         {
           // set unchanged polygons
-          std::vector< int >                  newQuantities;
+          std::vector< smIdType >             newQuantities;
           std::vector< _volumeDef::_nodeDef > newNodes;
           vector< SMESH_Block::TShapeID >     newNames;
           newQuantities.reserve( volDef->_quantities.size() );

src/StdMeshers/StdMeshers_PolyhedronPerSolid_3D.cxx

@@ -63,7 +63,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addHexa( std::vector< const SMDS_MeshElement* >& faces,
-                                   const std::vector< int > &              quantities,
+                                   const std::vector< smIdType > &         quantities,
                                    SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newHexa = 0;
@@ -134,7 +134,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addTetra( std::vector< const SMDS_MeshElement* >& faces,
-                                    const std::vector< int > &              quantities,
+                                    const std::vector< smIdType > &         quantities,
                                     SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newTetra = 0;
@@ -173,7 +173,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addPenta( std::vector< const SMDS_MeshElement* >& faces,
-                                    const std::vector< int > &              quantities,
+                                    const std::vector< smIdType > &         quantities,
                                     SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newPenta = 0;
@@ -232,7 +232,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addPyra( std::vector< const SMDS_MeshElement* >& faces,
-                                   const std::vector< int > &              quantities,
+                                   const std::vector< smIdType > &         quantities,
                                    SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newPyra = 0;
@@ -276,7 +276,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addHPrism( std::vector< const SMDS_MeshElement* >& faces,
-                                     const std::vector< int > &              quantities,
+                                     const std::vector< smIdType > &         quantities,
                                      SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newHexPrism = 0;
@@ -357,7 +357,7 @@ namespace
   //=======================================================================
 
   const SMDS_MeshElement* addPoly( std::vector< const SMDS_MeshElement* >& faces,
-                                   const std::vector< int > &              quantities,
+                                   const std::vector< smIdType > &         quantities,
                                    SMESH_MesherHelper &                    helper )
   {
     const SMDS_MeshElement* newPoly = 0;
@@ -508,7 +508,7 @@ bool StdMeshers_PolyhedronPerSolid_3D::Compute(SMESH_Mesh&         theMesh,
         for ( size_t i = 0; i < faces.size() &&  !useMediumNodes ; ++i )
           useMediumNodes = faces[ i ]->IsQuadratic();
 
-      std::vector< int > quantities( faces.size() );
+      std::vector< smIdType > quantities( faces.size() );
       std::set< const SMDS_MeshNode* > nodes;
       for ( size_t i = 0; i < faces.size(); ++i )
       {

src/StdMeshers/StdMeshers_Prism_3D.cxx

@@ -2329,7 +2329,7 @@ bool StdMeshers_Prism_3D::AddPrisms( vector<const TNodeColumn*> & columns,
     break;
   }
   default: // ---------- polyhedra
-    vector<int> quantities( 2 + nbNodes, 4 );
+    vector<smIdType> quantities( 2 + nbNodes, 4 );
     quantities[0] = quantities[1] = nbNodes;
     columns.resize( nbNodes + 1 );
     columns[ nbNodes ] = columns[ 0 ];