fix warnings. Build completed

diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index 8844ad904ac9d901c2a4381f1efe2b21aec546f1..b888ff0df3c7f2ea68272e77ba373df388ad331c 100644 (file)
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -2868,8 +2868,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) );
     }
   }
@@ -3020,7 +3020,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
@@ -3047,7 +3047,7 @@ void ConnectedElements::SetMesh( const SMDS_Mesh* theMesh )
   }
 }
 
-void ConnectedElements::SetNode( int nodeID )
+void ConnectedElements::SetNode( smIdType nodeID )
 {
   myNodeID = nodeID;
   myXYZ.clear();
@@ -3279,14 +3279,14 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
 {
   theResStr.Clear();
 
-  TColStd_SequenceOfInteger     anIntSeq;
+  TIDsSeq                             anIntSeq;
   TColStd_SequenceOfAsciiString aStrSeq;
 
   TIDsMap::Iterator anIter( myIds );
   for ( ; anIter.More(); anIter.Next() )
   {
-    int anId = anIter.Key();
-    TCollection_AsciiString aStr( anId );
+    smIdType anId = anIter.Key();
+    TCollection_AsciiString aStr( FromIdType<int>(anId) );
     anIntSeq.Append( anId );
     aStrSeq.Append( aStr );
   }
@@ -3300,7 +3300,7 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
     if ( aMinId != IntegerFirst() )
       aStr << aMinId;
 
-    aStr += "-";
+    aStr << "-";
 
     if ( aMaxId != std::numeric_limits<smIdType>::max() )
       aStr << aMaxId;

diff --git a/src/Controls/SMESH_ControlsDef.hxx b/src/Controls/SMESH_ControlsDef.hxx
index 596d0450e0f7947843add5379b39c8ea930deaea..1f6411b500e9bc37185aa4f2305739c4ba883f4d 100644 (file)
--- a/src/Controls/SMESH_ControlsDef.hxx
+++ b/src/Controls/SMESH_ControlsDef.hxx
@@ -59,6 +59,7 @@ class gp_Pln;
 class gp_Pnt;
 
 typedef NCollection_Map< smIdType, smIdHasher > TIDsMap;
+typedef NCollection_Sequence<smIdType> TIDsSeq;
 
 namespace SMESH{
   namespace Controls{
@@ -1164,16 +1165,16 @@ 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 );
       virtual              SMDSAbs_ElementType GetType() const;
 
       virtual void         SetMesh( const SMDS_Mesh* theMesh );
-      virtual bool         IsSatisfy( long theElementId );
+      virtual bool         IsSatisfy( smIdType theElementId );
 
       //const std::set<long>& GetDomainIDs() const { return myOkIDs; }
 

diff --git a/src/DriverCGNS/DriverCGNS_Read.cxx b/src/DriverCGNS/DriverCGNS_Read.cxx
index 4ac3e92c614aaf55bcbf2e9c3322dca6cd37e315..cfb37c3e4257ffea01e8863d4d35562934e8816a 100644 (file)
--- a/src/DriverCGNS/DriverCGNS_Read.cxx
+++ b/src/DriverCGNS/DriverCGNS_Read.cxx
@@ -61,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];
@@ -1133,7 +1133,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 )
             {

diff --git a/src/DriverCGNS/DriverCGNS_Write.cxx b/src/DriverCGNS/DriverCGNS_Write.cxx
index 6cbeae2fe9124f9b80e3b7c3aae677755c4783cf..bd6bcff2f17f899066969f95180523e944760884 100644 (file)
--- a/src/DriverCGNS/DriverCGNS_Write.cxx
+++ b/src/DriverCGNS/DriverCGNS_Write.cxx
@@ -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;
     }
@@ -276,7 +276,7 @@ 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 )

diff --git a/src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx b/src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
index 3440ee09a3e0e192475a6dff13d401e92550e46b..05d4900ef5669a6d29e68b932c1da13d34720c6d 100644 (file)
--- a/src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
+++ b/src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
@@ -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();
@@ -104,7 +104,7 @@ 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 );
@@ -120,7 +120,7 @@ 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 );
@@ -155,7 +155,7 @@ 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 );

diff --git a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
index 35520743691bd7f63ddc246a6dc0645642a8727b..375572dd50629e1c145d7579da2ad3b32590b39a 100644 (file)
--- a/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
+++ b/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
@@ -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){

diff --git a/src/MEDWrapper/MED_Common.hxx b/src/MEDWrapper/MED_Common.hxx
index d9d8253d39f81a78867f2b3e80fbb5db852d67cf..f6f6f2b0c62c1c6aad52d87b5c39d28ff62d5007 100644 (file)
--- a/src/MEDWrapper/MED_Common.hxx
+++ b/src/MEDWrapper/MED_Common.hxx
@@ -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;

diff --git a/src/SMDS/SMDS_VolumeTool.cxx b/src/SMDS/SMDS_VolumeTool.cxx
index 6f2ad3932004bc0c63980ec5ed6a4e3aa2a52b2a..a97d7d1438dff3efab2a982a642b3d7be0d05490 100644 (file)
--- a/src/SMDS/SMDS_VolumeTool.cxx
+++ b/src/SMDS/SMDS_VolumeTool.cxx
@@ -969,7 +969,7 @@ bool SMDS_VolumeTool::GetFaceNodes (int                             faceIndex,
 
 namespace
 {
-  struct NLink : public std::pair<int,int>
+  struct NLink : public std::pair<smIdType,smIdType>
   {
     int myOri;
     NLink(const SMDS_MeshNode* n1=0, const SMDS_MeshNode* n2=0, int ori=1 )

diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx
index 44555e3d92aa507a66c616133845c8121ccc741f..c3129299c68b6b5f67aff6ed26b9578ee647834a 100644 (file)
--- a/src/SMESH/SMESH_Algo.cxx
+++ b/src/SMESH/SMESH_Algo.cxx
@@ -1043,7 +1043,7 @@ int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
   int nbPoints = 0;
   for (TopExp_Explorer exp(W,TopAbs_EDGE); exp.More(); exp.Next()) {
     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
-    int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+    smIdType nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
     if(_quadraticMesh)
       nb = nb/2;
     nbPoints += nb + 1; // internal points plus 1 vertex of 2 (last point ?)

diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx
index 9ed363a17251602bd888c851959075cb107425bb..2ab047f0dbb4e0c3d560f06aa9c1825ae9b0e00a 100644 (file)
--- a/src/SMESH/SMESH_Mesh.cxx
+++ b/src/SMESH/SMESH_Mesh.cxx
@@ -1183,7 +1183,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
   if ( !GetMeshDS()->IsUsedHypothesis( hyp ))
     return;
 
-  int nbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
+  smIdType nbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
   if ( hyp && _callUp && !_callUp->IsLoaded() ) // for not loaded mesh (#16648)
   {
     _callUp->HypothesisModified( hyp->GetID(), /*updateIcons=*/true );
@@ -1257,7 +1257,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
   HasModificationsToDiscard(); // to reset _isModified flag if mesh becomes empty
   GetMeshDS()->Modified();
 
-  int newNbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
+  smIdType newNbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
   if ( hyp && _callUp )
     _callUp->HypothesisModified( hyp->GetID(), newNbEntities != nbEntities );
 }
@@ -1746,7 +1746,7 @@ double SMESH_Mesh::GetComputeProgress() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbNodes() const
+smIdType SMESH_Mesh::NbNodes() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbNodes();
@@ -1758,7 +1758,7 @@ int SMESH_Mesh::NbNodes() const
  */
 //================================================================================
 
-int SMESH_Mesh::Nb0DElements() const
+smIdType SMESH_Mesh::Nb0DElements() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().Nb0DElements();
@@ -1770,7 +1770,7 @@ int SMESH_Mesh::Nb0DElements() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbEdges(order);
@@ -1782,7 +1782,7 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbFaces(order);
@@ -1794,7 +1794,7 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriangles(order);
@@ -1806,7 +1806,7 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadTriangles() const
+smIdType SMESH_Mesh::NbBiQuadTriangles() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
@@ -1818,7 +1818,7 @@ int SMESH_Mesh::NbBiQuadTriangles() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
@@ -1830,7 +1830,7 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBiQuadQuadrangles() const
+smIdType SMESH_Mesh::NbBiQuadQuadrangles() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
@@ -1842,7 +1842,7 @@ int SMESH_Mesh::NbBiQuadQuadrangles() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolygons(order);
@@ -1854,7 +1854,7 @@ int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbVolumes(order);
@@ -1866,7 +1866,7 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTetras(order);
@@ -1878,7 +1878,7 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexas(order);
@@ -1890,7 +1890,7 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbTriQuadraticHexas() const
+smIdType SMESH_Mesh::NbTriQuadraticHexas() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
@@ -1902,7 +1902,7 @@ int SMESH_Mesh::NbTriQuadraticHexas() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPyramids(order);
@@ -1914,19 +1914,19 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
+smIdType SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPrisms(order);
 }
 
-int SMESH_Mesh::NbQuadPrisms() const
+smIdType SMESH_Mesh::NbQuadPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbQuadPrisms();
 }
 
-int SMESH_Mesh::NbBiQuadPrisms() const
+smIdType SMESH_Mesh::NbBiQuadPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
@@ -1939,7 +1939,7 @@ int SMESH_Mesh::NbBiQuadPrisms() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbHexagonalPrisms() const
+smIdType SMESH_Mesh::NbHexagonalPrisms() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbHexPrisms();
@@ -1951,7 +1951,7 @@ int SMESH_Mesh::NbHexagonalPrisms() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbPolyhedrons() const
+smIdType SMESH_Mesh::NbPolyhedrons() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbPolyhedrons();
@@ -1963,7 +1963,7 @@ int SMESH_Mesh::NbPolyhedrons() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbBalls() const
+smIdType SMESH_Mesh::NbBalls() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->GetMeshInfo().NbBalls();
@@ -1975,7 +1975,7 @@ int SMESH_Mesh::NbBalls() const
  */
 //================================================================================
 
-int SMESH_Mesh::NbSubMesh() const
+smIdType SMESH_Mesh::NbSubMesh() const
 {
   Unexpect aCatch(SalomeException);
   return _myMeshDS->NbSubMesh();

diff --git a/src/SMESH/SMESH_Mesh.hxx b/src/SMESH/SMESH_Mesh.hxx
index 4f9a3179de48cf7e9b425b6dcb5000816a2ef536..7c34bfee003f508d6976f8a58e5c6f5c34b1ce1e 100644 (file)
--- a/src/SMESH/SMESH_Mesh.hxx
+++ b/src/SMESH/SMESH_Mesh.hxx
@@ -282,31 +282,31 @@ class SMESH_EXPORT SMESH_Mesh
 
   double GetComputeProgress() const;
   
-  int NbNodes() const;
-  int Nb0DElements() const;
-  int NbBalls() const;
+  smIdType NbNodes() const;
+  smIdType Nb0DElements() const;
+  smIdType NbBalls() const;
   
-  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
   
-  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbBiQuadQuadrangles() const;
-  int NbBiQuadTriangles() const;
-  int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbBiQuadQuadrangles() const;
+  smIdType NbBiQuadTriangles() const;
+  smIdType NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
   
-  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbTriQuadraticHexas() const;
-  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
-  int NbQuadPrisms() const;
-  int NbBiQuadPrisms() const;
-  int NbHexagonalPrisms() const;
-  int NbPolyhedrons() const;
+  smIdType NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbTriQuadraticHexas() const;
+  smIdType NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  smIdType NbQuadPrisms() const;
+  smIdType NbBiQuadPrisms() const;
+  smIdType NbHexagonalPrisms() const;
+  smIdType NbPolyhedrons() const;
   
-  int NbSubMesh() const;
+  smIdType NbSubMesh() const;
   
   int NbGroup() const { return _mapGroup.size(); }
 

diff --git a/src/SMESH/SMESH_MeshEditor.cxx b/src/SMESH/SMESH_MeshEditor.cxx
index 50bca792e1e4a39a45479d485bcc4e7a1c55124e..3cb125ff2c426a91c15f925605969bcf82d14401 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.cxx
+++ b/src/SMESH/SMESH_MeshEditor.cxx
@@ -188,7 +188,7 @@ SMESH_MeshEditor::AddElement(const vector<const SMDS_MeshNode*> & node,
   SMDS_MeshElement* e = 0;
   int nbnode = node.size();
   SMESHDS_Mesh* mesh = GetMeshDS();
-  const int ID = features.myID;
+  const smIdType ID = features.myID;
 
   switch ( features.myType ) {
   case SMDSAbs_Face:
@@ -8751,7 +8751,7 @@ smIdType SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh *   theSm,
     }
     // get elem data needed to re-create it
     //
-    const int id      = elem->GetID();
+    const smIdType id = elem->GetID();
     const int nbNodes = elem->NbCornerNodes();
     nodes.assign(elem->begin_nodes(), elem->end_nodes());
     if ( aGeomType == SMDSEntity_Polyhedra )

diff --git a/src/SMESH/SMESH_Pattern.cxx b/src/SMESH/SMESH_Pattern.cxx
index 413b07edc297da94f40729b475b45b620441e82e..fb1ab2c177e68d186c6c728753e930bda8ffe039 100644 (file)
--- a/src/SMESH/SMESH_Pattern.cxx
+++ b/src/SMESH/SMESH_Pattern.cxx
@@ -574,8 +574,8 @@ bool SMESH_Pattern::Load (SMESH_Mesh*        theMesh,
   SMESH_MesherHelper helper( *theMesh );
   helper.SetSubShape( theFace );
 
-  int nbNodes = ( !fSubMesh ? 0 : fSubMesh->NbNodes() );
-  int nbElems = ( !fSubMesh ? 0 : fSubMesh->NbElements() );
+  smIdType nbNodes = ( !fSubMesh ? 0 : fSubMesh->NbNodes() );
+  smIdType nbElems = ( !fSubMesh ? 0 : fSubMesh->NbElements() );
   if ( nbElems == 0 && aMeshDS->NbFaces() == 0 )
   {
     MESSAGE( "No elements bound to the face");
@@ -3231,7 +3231,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh*         theMesh,
     return setErrorCode( ERR_LOADV_BAD_SHAPE );
 
   // count nodes
-  int nbNodes = 0, shapeID;
+  smIdType nbNodes = 0, shapeID;
   for ( shapeID = 1; shapeID <= myShapeIDMap.Extent(); shapeID++ )
   {
     const TopoDS_Shape& S = myShapeIDMap( shapeID );

diff --git a/src/SMESH/SMESH_ProxyMesh.cxx b/src/SMESH/SMESH_ProxyMesh.cxx
index 9bf11c371c385d641389706cda07fa1ea296e524..670e225dc9efb7c35aee2f077e8d6dc7c44f3b03 100644 (file)
--- a/src/SMESH/SMESH_ProxyMesh.cxx
+++ b/src/SMESH/SMESH_ProxyMesh.cxx
@@ -402,9 +402,9 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetFaces() const
  */
 //================================================================================
 
-int SMESH_ProxyMesh::NbFaces() const
+smIdType SMESH_ProxyMesh::NbFaces() const
 {
-  int nb = 0;
+  smIdType nb = 0;
   if ( _mesh->HasShapeToMesh() )
   {
     TopTools_IndexedMapOfShape FF;

diff --git a/src/SMESH/SMESH_ProxyMesh.hxx b/src/SMESH/SMESH_ProxyMesh.hxx
index aa7440f57e0a0d1b3ca70c12b6898358155385ed..1f88b85de11708b6b6c031a5b12db339366161f1 100644 (file)
--- a/src/SMESH/SMESH_ProxyMesh.hxx
+++ b/src/SMESH/SMESH_ProxyMesh.hxx
@@ -128,7 +128,7 @@ public:
   SMDS_ElemIteratorPtr   GetFaces(const TopoDS_Shape& face) const;
 
   // Return total nb of faces taking into account substitutions
-  int                    NbFaces() const;
+  smIdType               NbFaces() const;
 
   bool                   IsTemporary(const SMDS_MeshElement* elem ) const;
 

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index 03ad4d5fc36feb537625c6ef65ad0a42b5eb37fb..d9493b3c114633910a1bddece25683d17d465f50 100644 (file)
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -1331,12 +1331,12 @@ static void cleanSubMesh( SMESH_subMesh * subMesh )
     if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
     {
       SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
-      int nbElems = subMeshDS->NbElements();
+      smIdType nbElems = subMeshDS->NbElements();
       if ( nbElems > 0 )
         for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
           meshDS->RemoveFreeElement( ite->next(), subMeshDS );
 
-      int nbNodes = subMeshDS->NbNodes();
+      smIdType nbNodes = subMeshDS->NbNodes();
       if ( nbNodes > 0 )
         for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
         {