23237: EDF 12367 - SIGSEGV with Remove group

  (SMESH_Gen_i_1.cxx)

IPAL53059: Not all solids are highlighted by magenta
  (SMESHGUI_ComputeDlg.cxx)

+ remove "using namespace std" from headers

diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index 0623399e9dba8246b5958f7f32117d1937ec5324..bc79e1fc70abe3bc8d254029b6c9ab20bdf0201e 100644 (file)
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -175,7 +175,7 @@ namespace {
       n += q2 ^ q3;
     }
     double len = n.Modulus();
       n += q2 ^ q3;
     }
     double len = n.Modulus();

-    bool zeroLen = ( len <= numeric_limits<double>::min());
+    bool zeroLen = ( len <= std::numeric_limits<double>::min());

     if ( !zeroLen )
       n /= len;
 
     if ( !zeroLen )
       n /= len;
 


@@ -312,12 +312,12 @@ double NumericalFunctor::Round( const double & aVal )
  */
 //================================================================================
 
  */
 //================================================================================
 

-void NumericalFunctor::GetHistogram(int                  nbIntervals,
-                                    std::vector<int>&    nbEvents,
-                                    std::vector<double>& funValues,
-                                    const 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<int>& elements,
+                                    const double*           minmax,
+                                    const bool              isLogarithmic)

 {
   if ( nbIntervals < 1 ||
        !myMesh ||
 {
   if ( nbIntervals < 1 ||
        !myMesh ||


@@ -336,7 +336,7 @@ void NumericalFunctor::GetHistogram(int                  nbIntervals,
   }
   else
   {
   }
   else
   {

-    vector<int>::const_iterator id = elements.begin();
+    std::vector<int>::const_iterator id = elements.begin();

     for ( ; id != elements.end(); ++id )
       values.insert( GetValue( *id ));
   }
     for ( ; id != elements.end(); ++id )
       values.insert( GetValue( *id ));
   }


@@ -2163,7 +2163,7 @@ bool BareBorderVolume::IsSatisfy(long theElementId )
       if ( myTool.IsFreeFace( iF ))
       {
         const SMDS_MeshNode** n = myTool.GetFaceNodes(iF);
       if ( myTool.IsFreeFace( iF ))
       {
         const SMDS_MeshNode** n = myTool.GetFaceNodes(iF);

-        vector< const SMDS_MeshNode*> nodes( n, n+myTool.NbFaceNodes(iF));
+        std::vector< const SMDS_MeshNode*> nodes( n, n+myTool.NbFaceNodes(iF));

         if ( !myMesh->FindElement( nodes, SMDSAbs_Face, /*Nomedium=*/false))
           return true;
       }
         if ( !myMesh->FindElement( nodes, SMDSAbs_Face, /*Nomedium=*/false))
           return true;
       }


@@ -2302,15 +2302,15 @@ void CoincidentNodes::SetMesh( const SMDS_Mesh* theMesh )
     while ( nIt->more() )
       nodesToCheck.insert( nodesToCheck.end(), nIt->next() );
 
     while ( nIt->more() )
       nodesToCheck.insert( nodesToCheck.end(), nIt->next() );
 

-    list< list< const SMDS_MeshNode*> > nodeGroups;
+    std::list< std::list< const SMDS_MeshNode*> > nodeGroups;

     SMESH_OctreeNode::FindCoincidentNodes ( nodesToCheck, &nodeGroups, myToler );
 
     myCoincidentIDs.Clear();
     SMESH_OctreeNode::FindCoincidentNodes ( nodesToCheck, &nodeGroups, myToler );
 
     myCoincidentIDs.Clear();

-    list< list< const SMDS_MeshNode*> >::iterator groupIt = nodeGroups.begin();
+    std::list< std::list< const SMDS_MeshNode*> >::iterator groupIt = nodeGroups.begin();

     for ( ; groupIt != nodeGroups.end(); ++groupIt )
     {
     for ( ; groupIt != nodeGroups.end(); ++groupIt )
     {

-      list< const SMDS_MeshNode*>& coincNodes = *groupIt;
-      list< const SMDS_MeshNode*>::iterator n = coincNodes.begin();
+      std::list< const SMDS_MeshNode*>& coincNodes = *groupIt;
+      std::list< const SMDS_MeshNode*>::iterator n = coincNodes.begin();

       for ( ; n != coincNodes.end(); ++n )
         myCoincidentIDs.Add( (*n)->GetID() );
     }
       for ( ; n != coincNodes.end(); ++n )
         myCoincidentIDs.Add( (*n)->GetID() );
     }


@@ -2342,7 +2342,7 @@ bool CoincidentElements::IsSatisfy( long theElementId )
   if ( const SMDS_MeshElement* e = myMesh->FindElement( theElementId ))
   {
     if ( e->GetType() != GetType() ) return false;
   if ( const SMDS_MeshElement* e = myMesh->FindElement( theElementId ))
   {
     if ( e->GetType() != GetType() ) return false;

-    set< const SMDS_MeshNode* > elemNodes( e->begin_nodes(), e->end_nodes() );
+    std::set< const SMDS_MeshNode* > elemNodes( e->begin_nodes(), e->end_nodes() );

     const int nbNodes = e->NbNodes();
     SMDS_ElemIteratorPtr invIt = (*elemNodes.begin())->GetInverseElementIterator( GetType() );
     while ( invIt->more() )
     const int nbNodes = e->NbNodes();
     SMDS_ElemIteratorPtr invIt = (*elemNodes.begin())->GetInverseElementIterator( GetType() );
     while ( invIt->more() )


@@ -2589,18 +2589,20 @@ bool FreeFaces::IsSatisfy( long theId )
   int nbNode = aFace->NbNodes();
 
   // collect volumes to check that number of volumes with count equal nbNode not less than 2
   int nbNode = aFace->NbNodes();
 
   // collect volumes to check that number of volumes with count equal nbNode not less than 2

-  typedef map< SMDS_MeshElement*, int > TMapOfVolume; // map of volume counters
-  typedef map< SMDS_MeshElement*, int >::iterator TItrMapOfVolume; // iterator
+  typedef std::map< SMDS_MeshElement*, int > TMapOfVolume; // map of volume counters
+  typedef std::map< SMDS_MeshElement*, int >::iterator TItrMapOfVolume; // iterator

   TMapOfVolume mapOfVol;
 
   SMDS_ElemIteratorPtr nodeItr = aFace->nodesIterator();
   TMapOfVolume mapOfVol;
 
   SMDS_ElemIteratorPtr nodeItr = aFace->nodesIterator();

-  while ( nodeItr->more() ) {
+  while ( nodeItr->more() )
+  {

     const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(nodeItr->next());
     if ( !aNode ) continue;
     SMDS_ElemIteratorPtr volItr = aNode->GetInverseElementIterator(SMDSAbs_Volume);
     const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(nodeItr->next());
     if ( !aNode ) continue;
     SMDS_ElemIteratorPtr volItr = aNode->GetInverseElementIterator(SMDSAbs_Volume);

-    while ( volItr->more() ) {
+    while ( volItr->more() )
+    {

       SMDS_MeshElement* aVol = (SMDS_MeshElement*)volItr->next();
       SMDS_MeshElement* aVol = (SMDS_MeshElement*)volItr->next();

-      TItrMapOfVolume itr = mapOfVol.insert(make_pair(aVol, 0)).first;
+      TItrMapOfVolume    itr = mapOfVol.insert( std::make_pair( aVol, 0 )).first;

       (*itr).second++;
     } 
   }
       (*itr).second++;
     } 
   }


@@ -2704,8 +2706,8 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
     return;
 
   // iterates on groups and find necessary elements ids
     return;
 
   // iterates on groups and find necessary elements ids

-  const std::set<SMESHDS_GroupBase*>& aGroups = aMesh->GetGroups();
-  set<SMESHDS_GroupBase*>::const_iterator GrIt = aGroups.begin();
+  const std::set<SMESHDS_GroupBase*>&       aGroups = aMesh->GetGroups();
+  std::set<SMESHDS_GroupBase*>::const_iterator GrIt = aGroups.begin();

   for (; GrIt != aGroups.end(); GrIt++)
   {
     SMESHDS_GroupBase* aGrp = (*GrIt);
   for (; GrIt != aGroups.end(); GrIt++)
   {
     SMESHDS_GroupBase* aGrp = (*GrIt);


@@ -2932,10 +2934,10 @@ void ConnectedElements::SetPoint( double x, double y, double z )
   // find myNodeID by myXYZ if possible
   if ( myMeshModifTracer.GetMesh() )
   {
   // find myNodeID by myXYZ if possible
   if ( myMeshModifTracer.GetMesh() )
   {

-    auto_ptr<SMESH_ElementSearcher> searcher
+    SMESHUtils::Deleter<SMESH_ElementSearcher> searcher

       ( SMESH_MeshAlgos::GetElementSearcher( (SMDS_Mesh&) *myMeshModifTracer.GetMesh() ));
 
       ( SMESH_MeshAlgos::GetElementSearcher( (SMDS_Mesh&) *myMeshModifTracer.GetMesh() ));
 

-    vector< const SMDS_MeshElement* > foundElems;
+    std::vector< const SMDS_MeshElement* > foundElems;

     searcher->FindElementsByPoint( gp_Pnt(x,y,z), SMDSAbs_All, foundElems );
 
     if ( !foundElems.empty() )
     searcher->FindElementsByPoint( gp_Pnt(x,y,z), SMDSAbs_All, foundElems );
 
     if ( !foundElems.empty() )


@@ -2961,7 +2963,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
     if ( !node0 )
       return false;
 
     if ( !node0 )
       return false;
 

-    list< const SMDS_MeshNode* > nodeQueue( 1, node0 );
+    std::list< const SMDS_MeshNode* > nodeQueue( 1, node0 );

     std::set< int > checkedNodeIDs;
     // algo:
     // foreach node in nodeQueue:
     std::set< int > checkedNodeIDs;
     // algo:
     // foreach node in nodeQueue:


@@ -3050,8 +3052,8 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
     const double cosTol = Cos( myToler * M_PI / 180. );
     NCollection_Map< SMESH_TLink, SMESH_TLink > checkedLinks;
 
     const double cosTol = Cos( myToler * M_PI / 180. );
     NCollection_Map< SMESH_TLink, SMESH_TLink > checkedLinks;
 

-    std::list< pair< const SMDS_MeshElement*, gp_Vec > > faceQueue;
-    faceQueue.push_back( make_pair( face, myNorm ));
+    std::list< std::pair< const SMDS_MeshElement*, gp_Vec > > faceQueue;
+    faceQueue.push_back( std::make_pair( face, myNorm ));

     while ( !faceQueue.empty() )
     {
       face   = faceQueue.front().first;
     while ( !faceQueue.empty() )
     {
       face   = faceQueue.front().first;


@@ -3074,7 +3076,7 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
             if (!normOK || isLessAngle( myNorm, norm, cosTol))
             {
               myCoplanarIDs.Add( f->GetID() );
             if (!normOK || isLessAngle( myNorm, norm, cosTol))
             {
               myCoplanarIDs.Add( f->GetID() );

-              faceQueue.push_back( make_pair( f, norm ));
+              faceQueue.push_back( std::make_pair( f, norm ));

             }
           }
         }
             }
           }
         }

diff --git a/src/DriverGMF/DriverGMF_Write.cxx b/src/DriverGMF/DriverGMF_Write.cxx
index 963f1bc17383a1e81b5f64ee77eddefe5ea4ac44..5beadcd1797e55f3d144d7e5c36a2dc172b31fae 100644 (file)
--- a/src/DriverGMF/DriverGMF_Write.cxx
+++ b/src/DriverGMF/DriverGMF_Write.cxx
@@ -70,9 +70,9 @@ extern "C"
   elem->getshapeId() );                         \
   }}
 
   elem->getshapeId() );                         \
   }}
 

-#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id )         \
-  elem->getshapeId() );                                 \
-  e2id.insert( e2id.end(), make_pair( elem, gmfID ));   \
+#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id )            \
+  elem->getshapeId() );                                    \
+  e2id.insert( e2id.end(), std::make_pair( elem, gmfID )); \

   }}
 
 #define END_EXTRA_VERTICES_WRITE()           \
   }}
 
 #define END_EXTRA_VERTICES_WRITE()           \


@@ -145,7 +145,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
     const SMDS_MeshNode* n = nodeIt->next();
     n->GetXYZ( xyz );
     GmfSetLin( meshID, GmfVertices, xyz[0], xyz[1], xyz[2], n->getshapeId() );
     const SMDS_MeshNode* n = nodeIt->next();
     n->GetXYZ( xyz );
     GmfSetLin( meshID, GmfVertices, xyz[0], xyz[1], xyz[2], n->getshapeId() );

-    node2IdMap.insert( node2IdMap.end(), make_pair( n, ++iN ));
+    node2IdMap.insert( node2IdMap.end(), std::make_pair( n, ++iN ));

   }
   if ( iN != nbNodes )
     return addMessage("Wrong nb of nodes returned by nodesIterator", /*fatal=*/true);
   }
   if ( iN != nbNodes )
     return addMessage("Wrong nb of nodes returned by nodesIterator", /*fatal=*/true);

diff --git a/src/DriverMED/DriverMED_W_Field.cxx b/src/DriverMED/DriverMED_W_Field.cxx
index e40aac434f02d8d06962d5c802c21928845e12c8..5fa6a6317b9cdd32999d5ffacdf1a63a1a6daa4c 100644 (file)
--- a/src/DriverMED/DriverMED_W_Field.cxx
+++ b/src/DriverMED/DriverMED_W_Field.cxx
@@ -95,7 +95,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh *      mesh,
   if ( _nbElemsByGeom.empty() || _elemType != type )
   {
     _elemType = type;
   if ( _nbElemsByGeom.empty() || _elemType != type )
   {
     _elemType = type;

-    _nbElemsByGeom.resize( 1, make_pair( SMDSEntity_Last, 0 ));
+    _nbElemsByGeom.resize( 1, std::make_pair( SMDSEntity_Last, 0 ));

 
     // count nb of elems of each geometry
     for ( int iG = 0; iG < SMDSEntity_Last; ++iG )
 
     // count nb of elems of each geometry
     for ( int iG = 0; iG < SMDSEntity_Last; ++iG )


@@ -107,7 +107,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh *      mesh,
       nbElems = mesh->GetMeshInfo().NbElements( geom );
       if ( nbElems < 1 ) continue;
 
       nbElems = mesh->GetMeshInfo().NbElements( geom );
       if ( nbElems < 1 ) continue;
 

-      _nbElemsByGeom.push_back( make_pair( geom, nbElems + _nbElemsByGeom.back().second ));
+      _nbElemsByGeom.push_back( std::make_pair( geom, nbElems + _nbElemsByGeom.back().second ));

     }
     // add nodes of missing 0D elements on VERTEXes
     if ( _addODOnVertices && _elemType == SMDSAbs_0DElement )
     }
     // add nodes of missing 0D elements on VERTEXes
     if ( _addODOnVertices && _elemType == SMDSAbs_0DElement )


@@ -118,8 +118,8 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh *      mesh,
       if ( !nodes.empty() )
       {
         if ( _nbElemsByGeom.size() == 1 )
       if ( !nodes.empty() )
       {
         if ( _nbElemsByGeom.size() == 1 )

-          _nbElemsByGeom.push_back( make_pair( SMDSEntity_0D, 0));
-        _nbElemsByGeom.push_back( make_pair( SMDSEntity_Node,
+          _nbElemsByGeom.push_back( std::make_pair( SMDSEntity_0D, 0));
+        _nbElemsByGeom.push_back( std::make_pair( SMDSEntity_Node,

                                              nodes.size() + _nbElemsByGeom.back().second ));
       }
     }
                                              nodes.size() + _nbElemsByGeom.back().second ));
       }
     }


@@ -314,7 +314,7 @@ Driver_Mesh::Status DriverMED_W_Field::Perform()
     SMDSAbs_EntityType    smdsType = _nbElemsByGeom[iG].first;
     MED::EGeometrieElement medType = (MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );
     int                    nbElems = _nbElemsByGeom[iG].second - _nbElemsByGeom[iG-1].second;
     SMDSAbs_EntityType    smdsType = _nbElemsByGeom[iG].first;
     MED::EGeometrieElement medType = (MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );
     int                    nbElems = _nbElemsByGeom[iG].second - _nbElemsByGeom[iG-1].second;

-    type2nb.insert( make_pair( medType, nbElems ));
+    type2nb.insert( std::make_pair( medType, nbElems ));

   }
 
   MED::EEntiteMaillage       entity = ( _elemType == SMDSAbs_Node ? MED::eNOEUD : MED::eMAILLE );
   }
 
   MED::EEntiteMaillage       entity = ( _elemType == SMDSAbs_Node ? MED::eNOEUD : MED::eMAILLE );

diff --git a/src/SMDS/SMDS_Mesh.hxx b/src/SMDS/SMDS_Mesh.hxx
index b561d7571cc9f809ee0ac7437d4942d22501ceff..d233a00a3390aed783a5260bd003386f9bd61720 100644 (file)
--- a/src/SMDS/SMDS_Mesh.hxx
+++ b/src/SMDS/SMDS_Mesh.hxx
@@ -747,7 +747,7 @@ public:
   void incrementNodesCapacity(int nbNodes);
   void incrementCellsCapacity(int nbCells);
   void adjustStructure();
   void incrementNodesCapacity(int nbNodes);
   void incrementCellsCapacity(int nbCells);
   void adjustStructure();

-  void dumpGrid(string ficdump="dumpGrid");
+  void dumpGrid(std::string ficdump="dumpGrid");

   static int chunkSize;
 
   //! low level modification: add, change or remove node or element
   static int chunkSize;
 
   //! low level modification: add, change or remove node or element

diff --git a/src/SMDS/SMDS_MeshInfo.hxx b/src/SMDS/SMDS_MeshInfo.hxx
index 4c6dba726a1cc72f9c8911231a6c23d2d170ee8b..b0ccc82fa168708d467e3b630ee39aa5a7278911 100644 (file)
--- a/src/SMDS/SMDS_MeshInfo.hxx
+++ b/src/SMDS/SMDS_MeshInfo.hxx
@@ -25,7 +25,6 @@
 #define SMDS_MeshInfo_HeaderFile
 
 #include <vector>
 #define SMDS_MeshInfo_HeaderFile
 
 #include <vector>

-using namespace std;

 
 #include "SMESH_SMDS.hxx"
 
 
 #include "SMESH_SMDS.hxx"
 

diff --git a/src/SMDS/SMDS_VtkVolume.cxx b/src/SMDS/SMDS_VtkVolume.cxx
index d6da4357986d5150ab18dd623a541fae7e17e679..efc0f786c4e78b0b5a6539e083af60568d330eb3 100644 (file)
--- a/src/SMDS/SMDS_VtkVolume.cxx
+++ b/src/SMDS/SMDS_VtkVolume.cxx
@@ -95,7 +95,7 @@ void SMDS_VtkVolume::initPoly(const std::vector<vtkIdType>& nodeIds,
   SMDS_UnstructuredGrid* grid = mesh->getGrid();
   //double center[3];
   //this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), &center[0]);
   SMDS_UnstructuredGrid* grid = mesh->getGrid();
   //double center[3];
   //this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), &center[0]);

-  vector<vtkIdType> ptIds;
+  std::vector<vtkIdType> ptIds;

   vtkIdType nbFaces = nbNodesPerFace.size();
   int k = 0;
   for (int i = 0; i < nbFaces; i++)
   vtkIdType nbFaces = nbNodesPerFace.size();
   int k = 0;
   for (int i = 0; i < nbFaces; i++)


@@ -365,7 +365,7 @@ const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int n
  */
 std::vector<int> SMDS_VtkVolume::GetQuantities() const
 {
  */
 std::vector<int> SMDS_VtkVolume::GetQuantities() const
 {

-  vector<int> quantities;
+  std::vector<int> quantities;

   SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
   vtkUnstructuredGrid* grid = mesh->getGrid();
   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
   SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
   vtkUnstructuredGrid* grid = mesh->getGrid();
   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);

diff --git a/src/SMESH/SMESH_Algo.hxx b/src/SMESH/SMESH_Algo.hxx
index 6363dc469d4949411d6f380e7d869e937475893b..a362ed290bc272bef369bc1407e9535cfff4d04c 100644 (file)
--- a/src/SMESH/SMESH_Algo.hxx
+++ b/src/SMESH/SMESH_Algo.hxx
@@ -215,7 +215,7 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
    *  have a name (type) listed in the algorithm. Hypothesis associated to
    *  father shape -are not- taken into account (see GetUsedHypothesis)
    */
    *  have a name (type) listed in the algorithm. Hypothesis associated to
    *  father shape -are not- taken into account (see GetUsedHypothesis)
    */

-  const list <const SMESHDS_Hypothesis *> &
+  const std::list <const SMESHDS_Hypothesis *> &

   GetAppliedHypothesis(SMESH_Mesh &         aMesh,
                        const TopoDS_Shape & aShape,
                        const bool           ignoreAuxiliary=true) const;
   GetAppliedHypothesis(SMESH_Mesh &         aMesh,
                        const TopoDS_Shape & aShape,
                        const bool           ignoreAuxiliary=true) const;

diff --git a/src/SMESH/SMESH_MeshEditor.hxx b/src/SMESH/SMESH_MeshEditor.hxx
index a2039ac8a6e6d963c52abfb2d04ba783ab425104..f9695c9a1729841a71475d07139bdeb358072757 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.hxx
+++ b/src/SMESH/SMESH_MeshEditor.hxx
@@ -93,11 +93,11 @@ public:
     SMESH_EXPORT ElemFeatures& Init( double diameter )
     { myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; }
 
     SMESH_EXPORT ElemFeatures& Init( double diameter )
     { myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; }
 

-    SMESH_EXPORT ElemFeatures& Init( vector<int>& quanities, bool isQuad=false )
+    SMESH_EXPORT ElemFeatures& Init( std::vector<int>& quanities, bool isQuad=false )

     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities.swap( quanities ); return *this; }
 
     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities.swap( quanities ); return *this; }
 

-    SMESH_EXPORT ElemFeatures& Init( const vector<int>& quanities, bool isQuad=false )
+    SMESH_EXPORT ElemFeatures& Init( const std::vector<int>& quanities, bool isQuad=false )

     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities = quanities; return *this; }
 
     { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
       myPolyhedQuantities = quanities; return *this; }
 


@@ -777,8 +777,8 @@ public:
                                    const bool                             theHasRefPoint,
                                    const gp_Pnt&                          theRefPoint,
                                    const bool                             theMakeGroups);
                                    const bool                             theHasRefPoint,
                                    const gp_Pnt&                          theRefPoint,
                                    const bool                             theMakeGroups);

-  void LinearAngleVariation(const int     NbSteps,
-                            list<double>& theAngles);
+  void LinearAngleVariation(const int          NbSteps,
+                            std::list<double>& theAngles);

 
   bool doubleNodes( SMESHDS_Mesh*           theMeshDS,
                     const TIDSortedElemSet& theElems,
 
   bool doubleNodes( SMESHDS_Mesh*           theMeshDS,
                     const TIDSortedElemSet& theElems,

diff --git a/src/SMESH/SMESH_ProxyMesh.cxx b/src/SMESH/SMESH_ProxyMesh.cxx
index 962ba92a56084ec932cda6c1eed5a8a704e3c038..5271a6c17ad879c35d5e4e2fed65968714275936 100644 (file)
--- a/src/SMESH/SMESH_ProxyMesh.cxx
+++ b/src/SMESH/SMESH_ProxyMesh.cxx
@@ -45,7 +45,7 @@ SMESH_ProxyMesh::SMESH_ProxyMesh():_mesh(0)
  */
 //================================================================================
 
  */
 //================================================================================
 

-SMESH_ProxyMesh::SMESH_ProxyMesh(vector<SMESH_ProxyMesh::Ptr>& components):
+SMESH_ProxyMesh::SMESH_ProxyMesh(std::vector<SMESH_ProxyMesh::Ptr>& components):

   _mesh(0)
 {
   if ( components.empty() ) return;
   _mesh(0)
 {
   if ( components.empty() ) return;


@@ -68,8 +68,8 @@ SMESH_ProxyMesh::SMESH_ProxyMesh(vector<SMESH_ProxyMesh::Ptr>& components):
       if ( _subMeshes[j] )
       {
         // unite 2 sub-meshes
       if ( _subMeshes[j] )
       {
         // unite 2 sub-meshes

-        set< const SMDS_MeshElement * > elems( _subMeshes[j]->_elements.begin(),
-                                               _subMeshes[j]->_elements.end());
+        std::set< const SMDS_MeshElement * > elems( _subMeshes[j]->_elements.begin(),
+                                                    _subMeshes[j]->_elements.end());

         elems.insert( m->_subMeshes[j]->_elements.begin(),
                       m->_subMeshes[j]->_elements.end());
         _subMeshes[j]->_elements.assign( elems.begin(), elems.end() );
         elems.insert( m->_subMeshes[j]->_elements.begin(),
                       m->_subMeshes[j]->_elements.end());
         _subMeshes[j]->_elements.assign( elems.begin(), elems.end() );


@@ -103,7 +103,7 @@ SMESH_ProxyMesh::~SMESH_ProxyMesh()
     delete _subMeshes[i];
   _subMeshes.clear();
 
     delete _subMeshes[i];
   _subMeshes.clear();
 

-  set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.begin();
+  std::set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.begin();

   for ( ; i != _elemsInMesh.end(); ++i )
     GetMeshDS()->RemoveFreeElement( *i, 0 );
   _elemsInMesh.clear();
   for ( ; i != _elemsInMesh.end(); ++i )
     GetMeshDS()->RemoveFreeElement( *i, 0 );
   _elemsInMesh.clear();


@@ -203,12 +203,12 @@ namespace
 
   class TFilteringIterator : public SMDS_ElemIterator
   {
 
   class TFilteringIterator : public SMDS_ElemIterator
   {

-    SMDS_ElemIteratorPtr        _iter;
-    const SMDS_MeshElement *    _curElem;
-    vector< SMDSAbs_EntityType> _okTypes;
+    SMDS_ElemIteratorPtr             _iter;
+    const SMDS_MeshElement *         _curElem;
+    std::vector< SMDSAbs_EntityType> _okTypes;

   public:
   public:

-    TFilteringIterator( const vector< SMDSAbs_EntityType>& okTypes,
-                        const SMDS_ElemIteratorPtr&        elemIterator)
+    TFilteringIterator( const std::vector< SMDSAbs_EntityType>& okTypes,
+                        const SMDS_ElemIteratorPtr&             elemIterator)

       :_iter(elemIterator), _curElem(0), _okTypes(okTypes)
     {
       next();
       :_iter(elemIterator), _curElem(0), _okTypes(okTypes)
     {
       next();


@@ -282,11 +282,11 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetFaces() const
   // ... else elements filtered using allowedTypes are additionally returned
   SMDS_ElemIteratorPtr facesIter = GetMeshDS()->elementsIterator(SMDSAbs_Face);
   SMDS_ElemIteratorPtr filterIter( new TFilteringIterator( _allowedTypes, facesIter ));
   // ... else elements filtered using allowedTypes are additionally returned
   SMDS_ElemIteratorPtr facesIter = GetMeshDS()->elementsIterator(SMDSAbs_Face);
   SMDS_ElemIteratorPtr filterIter( new TFilteringIterator( _allowedTypes, facesIter ));

-  vector< SMDS_ElemIteratorPtr > iters(2);
+  std::vector< SMDS_ElemIteratorPtr > iters(2);

   iters[0] = proxyIter;
   iters[1] = filterIter;
     
   iters[0] = proxyIter;
   iters[1] = filterIter;
     

-  typedef vector< SMDS_ElemIteratorPtr > TElemIterVector;
+  typedef std::vector< SMDS_ElemIteratorPtr >                                 TElemIterVector;

   typedef SMDS_IteratorOnIterators<const SMDS_MeshElement *, TElemIterVector> TItersIter;
   return SMDS_ElemIteratorPtr( new TItersIter( iters ));
 }
   typedef SMDS_IteratorOnIterators<const SMDS_MeshElement *, TElemIterVector> TItersIter;
   return SMDS_ElemIteratorPtr( new TItersIter( iters ));
 }


@@ -431,7 +431,7 @@ void SMESH_ProxyMesh::removeTmpElement( const SMDS_MeshElement* elem )
 {
   if ( elem && elem->GetID() > 0 )
   {
 {
   if ( elem && elem->GetID() > 0 )
   {

-    set< const SMDS_MeshElement* >::iterator i =  _elemsInMesh.find( elem );
+    std::set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.find( elem );

     if ( i != _elemsInMesh.end() )
     {
       GetMeshDS()->RemoveFreeElement( elem, 0 );
     if ( i != _elemsInMesh.end() )
     {
       GetMeshDS()->RemoveFreeElement( elem, 0 );


@@ -468,7 +468,7 @@ void SMESH_ProxyMesh::setNode2Node(const SMDS_MeshNode* srcNode,
   SubMesh* sm = const_cast<SubMesh*>( subMesh );
   if ( !subMesh->_n2n )
     sm->_n2n = new TN2NMap;
   SubMesh* sm = const_cast<SubMesh*>( subMesh );
   if ( !subMesh->_n2n )
     sm->_n2n = new TN2NMap;

-  sm->_n2n->insert( make_pair( srcNode, proxyNode ));
+  sm->_n2n->insert( std::make_pair( srcNode, proxyNode ));

 }
 
 //================================================================================
 }
 
 //================================================================================

diff --git a/src/SMESHClient/SMESH_Client.cxx b/src/SMESHClient/SMESH_Client.cxx
index 4c9cac3534e341d87df515339a2e1079962cc1db..a1cee8e4e3a9cdb31030114d1c614a763dc69546 100644 (file)
--- a/src/SMESHClient/SMESH_Client.cxx
+++ b/src/SMESHClient/SMESH_Client.cxx
@@ -61,6 +61,7 @@ static int MYDEBUG = 0;
 
 namespace
 {
 
 namespace
 {

+  using std::runtime_error;

 
   //=======================================================================
   //function : FindNode
 
   //=======================================================================
   //function : FindNode


@@ -972,7 +973,7 @@ SMESH_Client::Update(bool theIsClear)
             int nbNodes = anIndexes[i++];
             // nodes
             //ASSERT( nbNodes < 9 );
             int nbNodes = anIndexes[i++];
             // nodes
             //ASSERT( nbNodes < 9 );

-            vector<const SMDS_MeshNode*> aNodes( nbNodes );
+            std::vector<const SMDS_MeshNode*> aNodes( nbNodes );

             for ( int iNode = 0; iNode < nbNodes; iNode++ )
               aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
             // change
             for ( int iNode = 0; iNode < nbNodes; iNode++ )
               aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
             // change

diff --git a/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx b/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
index deacb22f01de69ddc4f234d1de56f1ef1564f02a..f28b8c95c08630b6b7f2ffad3d35db11272e27a8 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
@@ -118,8 +118,8 @@ namespace
   static int FirstHexahedronIds[] = {0,1,2,3,4,5,6,7,0,1,2,3};
   static int LastHexahedronIds[] =  {1,2,3,0,5,6,7,4,4,5,6,7};
 
   static int FirstHexahedronIds[] = {0,1,2,3,4,5,6,7,0,1,2,3};
   static int LastHexahedronIds[] =  {1,2,3,0,5,6,7,4,4,5,6,7};
 

-  static vector<int> FirstPolygonIds;
-  static vector<int> LastPolygonIds;
+  static std::vector<int> FirstPolygonIds;
+  static std::vector<int> LastPolygonIds;

 
   void ReverseConnectivity( std::vector<vtkIdType> & ids, SMDSAbs_EntityType type,
                             bool toReverse, // inverse element
 
   void ReverseConnectivity( std::vector<vtkIdType> & ids, SMDSAbs_EntityType type,
                             bool toReverse, // inverse element

diff --git a/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx b/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
index 001416791ad056a09988b62c22399a735937a12f..4cf85c89f75b657411ed10b703cfbe06db96c9f8 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
@@ -108,6 +108,7 @@
 #define MARGIN  11
 
 #define COLONIZE(str)   (QString(str).contains(":") > 0 ? QString(str) : QString(str) + " :" )
 #define MARGIN  11
 
 #define COLONIZE(str)   (QString(str).contains(":") > 0 ? QString(str) : QString(str) + " :" )

+#define __SHAPE_RGB__ 250, 0, 250

 
 enum TCol {
   COL_ALGO = 0, COL_SHAPE, COL_ERROR, COL_SHAPEID, COL_PUBLISHED, COL_BAD_MESH, NB_COLUMNS
 
 enum TCol {
   COL_ALGO = 0, COL_SHAPE, COL_ERROR, COL_SHAPEID, COL_PUBLISHED, COL_BAD_MESH, NB_COLUMNS


@@ -147,10 +148,10 @@ namespace SMESH
     {
       myProperty = vtkProperty::New();
       myProperty->SetRepresentationToWireframe();
     {
       myProperty = vtkProperty::New();
       myProperty->SetRepresentationToWireframe();

-      myProperty->SetColor( 250, 0, 250 );
-      myProperty->SetAmbientColor( 250, 0, 250 );
-      myProperty->SetDiffuseColor( 250, 0, 250 );
-      //myProperty->SetSpecularColor( 250, 0, 250 );
+      myProperty->SetColor( __SHAPE_RGB__ );
+      myProperty->SetAmbientColor( __SHAPE_RGB__ );
+      myProperty->SetDiffuseColor( __SHAPE_RGB__ );
+      //myProperty->SetSpecularColor( __SHAPE_RGB__ );

       myProperty->SetLineWidth( 5 );
     }
     // -----------------------------------------------------------------------
       myProperty->SetLineWidth( 5 );
     }
     // -----------------------------------------------------------------------


@@ -278,13 +279,18 @@ namespace SMESH
         actor = GEOM_Actor::New();
         if ( actor ) {
           actor->SetShape(shape,0,0);
         actor = GEOM_Actor::New();
         if ( actor ) {
           actor->SetShape(shape,0,0);

-          actor->SetProperty(myProperty);
-          actor->SetShadingProperty(myProperty);
-          actor->SetWireframeProperty(myProperty);
-          actor->SetPreviewProperty(myProperty);
+          // actor->SetProperty(myProperty);
+          // actor->SetShadingProperty(myProperty);
+          // actor->SetWireframeProperty(myProperty);
+          // actor->SetPreviewProperty(myProperty);

           actor->PickableOff();
           actor->PickableOff();

-          //         if ( shape.ShapeType() == TopAbs_EDGE )
-          //           actor->SubShapeOn();
+          //
+          actor->SetWidth( myProperty->GetLineWidth() );
+          actor->SetIsosWidth( myProperty->GetLineWidth() );
+          actor->SetIsosColor( __SHAPE_RGB__ );
+          actor->SetColor( __SHAPE_RGB__ );
+          // if ( shape.ShapeType() == TopAbs_EDGE )
+          //   actor->SubShapeOn();

           myViewWindow->AddActor( actor );
         }
       }
           myViewWindow->AddActor( actor );
         }
       }


@@ -732,10 +738,11 @@ void SMESHGUI_ComputeDlg_QThread::cancel()
 //================================================================================
 //================================================================================
 
 //================================================================================
 //================================================================================
 

-SMESHGUI_ComputeDlg_QThreadQDialog::SMESHGUI_ComputeDlg_QThreadQDialog(QWidget             * parent,
-                                                                       SMESH::SMESH_Gen_var  gen,
-                                                                       SMESH::SMESH_Mesh_var mesh,
-                                                                       GEOM::GEOM_Object_var mainShape)
+SMESHGUI_ComputeDlg_QThreadQDialog::
+SMESHGUI_ComputeDlg_QThreadQDialog(QWidget             * parent,
+                                   SMESH::SMESH_Gen_var  gen,
+                                   SMESH::SMESH_Mesh_var mesh,
+                                   GEOM::GEOM_Object_var mainShape)

   : QDialog(parent,
             Qt::WindowSystemMenuHint |
             Qt::WindowCloseButtonHint |
   : QDialog(parent,
             Qt::WindowSystemMenuHint |
             Qt::WindowCloseButtonHint |


@@ -916,23 +923,28 @@ void SMESHGUI_BaseComputeOp::computeMesh()
       if ( !memoryLack )
       {
         // List of objects that will be updated automatically
       if ( !memoryLack )
       {
         // List of objects that will be updated automatically

-        QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > > aListToUpdate;
-        SMESH::SMESH_IDSource_var aMeshObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aMeshSObj );
+        typedef QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > > TListOf_IDSrc_SObj;
+        TListOf_IDSrc_SObj aListToUpdate;
+        SMESH::SMESH_IDSource_var aMeshObj =
+          SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aMeshSObj );

         // put Mesh into list
         // put Mesh into list

-        aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aMeshObj, aMeshSObj) );
+        aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aMeshObj, aMeshSObj ));

         SMESH::submesh_array_var aSubMeshes = myMesh->GetSubMeshes();
         // put SubMeshes into list
         SMESH::submesh_array_var aSubMeshes = myMesh->GetSubMeshes();
         // put SubMeshes into list

-        for ( CORBA::ULong i = 0; i < aSubMeshes->length(); i++ ) {
+        for ( CORBA::ULong i = 0; i < aSubMeshes->length(); i++ )
+        {

           SMESH::SMESH_subMesh_var sm = aSubMeshes[i];
           if ( CORBA::is_nil( sm ) ) continue;
           _PTR(SObject) smSObj = SMESH::ObjectToSObject( sm );
           if ( !smSObj ) continue;
           SMESH::SMESH_subMesh_var sm = aSubMeshes[i];
           if ( CORBA::is_nil( sm ) ) continue;
           _PTR(SObject) smSObj = SMESH::ObjectToSObject( sm );
           if ( !smSObj ) continue;

-          SMESH::SMESH_IDSource_var aSubMeshObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( smSObj );
-          aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aSubMeshObj, smSObj) );
+          SMESH::SMESH_IDSource_var aSubMeshObj =
+            SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( smSObj );
+          aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aSubMeshObj, smSObj ));

         }
         // put Groups into list
         }
         // put Groups into list

-        SMESH::ListOfGroups_var  aGroups = myMesh->GetGroups();
-        for ( size_t i = 0; i < aGroups->length(); ++i ) {
+        SMESH::ListOfGroups_var aGroups = myMesh->GetGroups();
+        for ( size_t i = 0; i < aGroups->length(); ++i )
+        {

           SMESH::SMESH_GroupBase_var aGrp = aGroups[i];
           if ( CORBA::is_nil( aGrp ) ) continue;
           SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
           SMESH::SMESH_GroupBase_var aGrp = aGroups[i];
           if ( CORBA::is_nil( aGrp ) ) continue;
           SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );


@@ -941,26 +953,31 @@ void SMESHGUI_BaseComputeOp::computeMesh()
           if ( !aStdGroup->_is_nil() ) continue; // don't update the standalone groups
           _PTR(SObject) aGroupSO = SMESH::FindSObject( aGrp );
           if ( !aGroupSO ) continue;
           if ( !aStdGroup->_is_nil() ) continue; // don't update the standalone groups
           _PTR(SObject) aGroupSO = SMESH::FindSObject( aGrp );
           if ( !aGroupSO ) continue;

-          SMESH::SMESH_IDSource_var aGroupObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aGroupSO );
-          aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aGroupObj, aGroupSO) );
+          SMESH::SMESH_IDSource_var aGroupObj =
+            SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aGroupSO );
+          aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aGroupObj, aGroupSO ));

         }
 
         // update mesh, sub-mesh and groups, if it's possible
         }
 
         // update mesh, sub-mesh and groups, if it's possible

-        QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > >::iterator anIter;
-        for( anIter = aListToUpdate.begin(); anIter != aListToUpdate.end(); anIter++ ) {
-          SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( (*anIter).second ));
-          if ( getSMESHGUI()->automaticUpdate( (*anIter).first, &entities, &limitExceeded, &hidden, &nbElements ) )
+        TListOf_IDSrc_SObj::iterator anIter;
+        for ( anIter = aListToUpdate.begin(); anIter != aListToUpdate.end(); anIter++ )
+        {
+          SMESH::SMESH_Mesh_var aMesh =
+            SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( (*anIter).second ));
+
+          if ( getSMESHGUI()->automaticUpdate( (*anIter).first, &entities, &limitExceeded,
+                                               &hidden, &nbElements ) )

           {
             try {
           {
             try {

-#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100

               OCC_CATCH_SIGNALS;
               OCC_CATCH_SIGNALS;

-#endif

               bool toDisplay = false;
               bool toDisplay = false;

-
-              if ( !aMesh->_is_nil() ) { // display a mesh only
+              if ( !aMesh->_is_nil() ) // display only a mesh
+              {

                 toDisplay = true;
                 SMESH_Actor *anActor = SMESH::FindActorByObject( aMesh );
                 toDisplay = true;
                 SMESH_Actor *anActor = SMESH::FindActorByObject( aMesh );

-                if ( !anActor ) anActor = SMESH::CreateActor( (*anIter).second->GetStudy(), (*anIter).second->GetID().c_str(), true );    
+                if ( !anActor ) anActor = SMESH::CreateActor( (*anIter).second->GetStudy(),
+                                                              (*anIter).second->GetID().c_str(),
+                                                              /*clearLog =*/ true );

                 if ( anActor ) // actor is not created for an empty mesh
                 {
                   anActor->SetEntityMode( entities );
                 if ( anActor ) // actor is not created for an empty mesh
                 {
                   anActor->SetEntityMode( entities );


@@ -981,7 +998,10 @@ void SMESHGUI_BaseComputeOp::computeMesh()
                 if ( hidden & SMESH_Actor::eBallElem )   hiddenMsg << tr( "SMESH_BALLS" );
                 SUIT_MessageBox::warning( desktop(),
                                           tr( "SMESH_WRN_WARNING" ),
                 if ( hidden & SMESH_Actor::eBallElem )   hiddenMsg << tr( "SMESH_BALLS" );
                 SUIT_MessageBox::warning( desktop(),
                                           tr( "SMESH_WRN_WARNING" ),

-                                          tr( "SMESH_WRN_SIZE_INC_LIMIT_EXCEEDED" ).arg( nbElements ).arg( limitSize ).arg( hiddenMsg.join(", ") ) );
+                                          tr( "SMESH_WRN_SIZE_INC_LIMIT_EXCEEDED" ).
+                                          arg( nbElements ).
+                                          arg( limitSize ).
+                                          arg( hiddenMsg.join(", ")));

               }
             }
             catch (...) {
               }
             }
             catch (...) {


@@ -1000,12 +1020,12 @@ void SMESHGUI_BaseComputeOp::computeMesh()
           {
             SUIT_MessageBox::warning( desktop(),
                                       tr( "SMESH_WRN_WARNING" ),
           {
             SUIT_MessageBox::warning( desktop(),
                                       tr( "SMESH_WRN_WARNING" ),

-                                      tr( "SMESH_WRN_SIZE_LIMIT_EXCEEDED" ).arg( nbElements ).arg( limitSize ) );
+                                      tr( "SMESH_WRN_SIZE_LIMIT_EXCEEDED" ).
+                                      arg( nbElements ).arg( limitSize ) );

           }
         }
       }
           }
         }
       }

-      LightApp_SelectionMgr *Sel = selectionMgr();
-      if ( Sel )
+      if ( LightApp_SelectionMgr *Sel = selectionMgr() )

       {
         SALOME_ListIO selected;
         selected.Append( myIObject );
       {
         SALOME_ListIO selected;
         selected.Append( myIObject );


@@ -1017,10 +1037,11 @@ void SMESHGUI_BaseComputeOp::computeMesh()
   if ( memoryLack )
     aMemoryReserve.release();
 
   if ( memoryLack )
     aMemoryReserve.release();
 

-  myCompDlg->setWindowTitle(tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED"));
+  myCompDlg->setWindowTitle
+    ( tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED" ));

 
   // SHOW ERRORS
 
   // SHOW ERRORS

-  
+

   bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
   bool noHypoError = ( aHypErrors.isEmpty() );
 
   bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
   bool noHypoError = ( aHypErrors.isEmpty() );
 


@@ -1234,8 +1255,9 @@ void SMESHGUI_BaseComputeOp::onPublishShape()
       if ( !SMESH::getSubShapeSO( 1, myMainShape )) // the main shape not published
       {
         QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( myMainShape, "MAIN_SHAPE" ));
       if ( !SMESH::getSubShapeSO( 1, myMainShape )) // the main shape not published
       {
         QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( myMainShape, "MAIN_SHAPE" ));

-        SALOMEDS::SObject_wrap so =
-          geomGen->AddInStudy( study, myMainShape, name.toLatin1().data(), GEOM::GEOM_Object::_nil());
+        SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, myMainShape,
+                                                         name.toLatin1().data(),
+                                                         GEOM::GEOM_Object::_nil());

         // look for myMainShape in the table
         for ( int r = 0, nr = table()->rowCount(); r < nr; ++r ) {
           if ( table()->item( r, COL_SHAPEID )->text() == "1" ) {
         // look for myMainShape in the table
         for ( int r = 0, nr = table()->rowCount(); r < nr; ++r ) {
           if ( table()->item( r, COL_SHAPEID )->text() == "1" ) {


@@ -1252,7 +1274,8 @@ void SMESHGUI_BaseComputeOp::onPublishShape()
         if ( curSub == 1 ) continue;
       }
       QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( shape, "ERROR_SHAPE" ));
         if ( curSub == 1 ) continue;
       }
       QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( shape, "ERROR_SHAPE" ));

-      SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, shape, name.toLatin1().data(), myMainShape);
+      SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, shape,
+                                                       name.toLatin1().data(), myMainShape);

       if ( !so->_is_nil() ) {
         CORBA::String_var name  = so->GetName();
         CORBA::String_var entry = so->GetID();
       if ( !so->_is_nil() ) {
         CORBA::String_var name  = so->GetName();
         CORBA::String_var entry = so->GetID();


@@ -1995,7 +2018,8 @@ void SMESHGUI_PrecomputeOp::onPreview()
   if ( isShowError )
   {
     myDlg->hide();
   if ( isShowError )
   {
     myDlg->hide();

-    aCompDlg->setWindowTitle(tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED"));
+    aCompDlg->setWindowTitle
+      ( tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED" ));

     showComputeResult( memoryLack, noCompError, aCompErrors, noHypoError, aHypErrors );
   }
 }
     showComputeResult( memoryLack, noCompError, aCompErrors, noHypoError, aHypErrors );
   }
 }


@@ -2198,10 +2222,11 @@ void SMESHGUI_BaseComputeOp::evaluateMesh()
     aMemoryReserve.release();
 
   evaluateFailed =  ( aCompErrors->length() > 0 );
     aMemoryReserve.release();
 
   evaluateFailed =  ( aCompErrors->length() > 0 );

-  myCompDlg->setWindowTitle(tr( evaluateFailed ? "SMESH_WRN_EVALUATE_FAILED" : "SMESH_EVALUATE_SUCCEED"));
+  myCompDlg->setWindowTitle
+    ( tr( evaluateFailed ? "SMESH_WRN_EVALUATE_FAILED" : "SMESH_EVALUATE_SUCCEED" ));

 
   // SHOW ERRORS
 
   // SHOW ERRORS

-  
+

   bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
   bool noHypoError = ( aHypErrors.isEmpty() );
 
   bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
   bool noHypoError = ( aHypErrors.isEmpty() );
 

diff --git a/src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx b/src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
index d598d95e9231b99cd6f28c890ec2da58e09e32df..ffae8359b7c51b8197bb48316a5d1432341e7ee8 100755 (executable)
--- a/src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
@@ -1852,7 +1852,7 @@ void SMESHGUI_SplitVolumesDlg::showFacetByElement( int elemID )
   gp_XYZ bc( 0,0,0 );
   Bnd_B3d bbox;
   SMDS_NodeIteratorPtr nIt = elem->nodeIterator();
   gp_XYZ bc( 0,0,0 );
   Bnd_B3d bbox;
   SMDS_NodeIteratorPtr nIt = elem->nodeIterator();

-  vector< const SMDS_MeshNode* > nodes;
+  std::vector< const SMDS_MeshNode* > nodes;

   nodes.reserve( elem->NbNodes() );
   while ( nIt->more() )
   {
   nodes.reserve( elem->NbNodes() );
   while ( nIt->more() )
   {

diff --git a/src/SMESHUtils/SMESH_Comment.hxx b/src/SMESHUtils/SMESH_Comment.hxx
index 5e6420fda11f1dfb98d2f34f4d9612c64475893b..bb4c9b48748f6f0d97551da39d8d7a284db4054f 100644 (file)
--- a/src/SMESHUtils/SMESH_Comment.hxx
+++ b/src/SMESHUtils/SMESH_Comment.hxx
@@ -30,40 +30,38 @@
 # include <string>
 # include <sstream>
 
 # include <string>
 # include <sstream>
 

-using namespace std;
-

 /*!
  * \brief Class to generate string from any type
  */
 /*!
  * \brief Class to generate string from any type
  */

-class SMESH_Comment : public string
+class SMESH_Comment : public std::string

 {
 {

-  ostringstream _s ;
+  std::ostringstream _s ;

 
 public :
 
 
 public :
 

-  SMESH_Comment():string("") {}
+  SMESH_Comment():std::string("") {}

 
 

-  SMESH_Comment(const SMESH_Comment& c):string() {
+  SMESH_Comment(const SMESH_Comment& c):std::string() {

     _s << c.c_str() ;
     _s << c.c_str() ;

-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );

   }
 
   SMESH_Comment & operator=(const SMESH_Comment& c) {
     _s << c.c_str() ;
   }
 
   SMESH_Comment & operator=(const SMESH_Comment& c) {
     _s << c.c_str() ;

-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );

     return *this;
   }
 
   template <class T>
   SMESH_Comment( const T &anything ) {
     _s << anything ;
     return *this;
   }
 
   template <class T>
   SMESH_Comment( const T &anything ) {
     _s << anything ;

-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );

   }
 
   template <class T>
   SMESH_Comment & operator<<( const T &anything ) {
     _s << anything ;
   }
 
   template <class T>
   SMESH_Comment & operator<<( const T &anything ) {
     _s << anything ;

-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );

     return *this ;
   }
 
     return *this ;
   }
 

diff --git a/src/SMESHUtils/SMESH_FreeBorders.cxx b/src/SMESHUtils/SMESH_FreeBorders.cxx
index 52018179e8a0f562d8c64e025172f7b13284f3a5..87951012c3389ea15cbe6a9d36b54565862f7a6e 100644 (file)
--- a/src/SMESHUtils/SMESH_FreeBorders.cxx
+++ b/src/SMESHUtils/SMESH_FreeBorders.cxx
@@ -290,7 +290,7 @@ namespace
   void BNode::AddClose ( const BEdge* e, double u ) const
   {
     if ( ! e->Contains( this ))
   void BNode::AddClose ( const BEdge* e, double u ) const
   {
     if ( ! e->Contains( this ))

-      myCloseEdges.push_back( make_pair( const_cast< BEdge* >( e ), u ));
+      myCloseEdges.push_back( std::make_pair( const_cast< BEdge* >( e ), u ));

   }
   BEdge* BNode::GetCloseEdgeOfBorder( int borderID, double * uPtr ) const
   {
   }
   BEdge* BNode::GetCloseEdgeOfBorder( int borderID, double * uPtr ) const
   {


@@ -569,9 +569,9 @@ void SMESH_MeshAlgos::FindCoincidentFreeBorders(SMDS_Mesh&              mesh,
 
   // form groups of coincident parts of free borders
 
 
   // form groups of coincident parts of free borders
 

-  TFreeBorderPart  part;
-  TCoincidentGroup group;
-  vector< BEdge* > ranges; // couples of edges delimiting parts
+  TFreeBorderPart       part;
+  TCoincidentGroup      group;
+  std::vector< BEdge* > ranges; // couples of edges delimiting parts

   BEdge* be = 0; // a current edge
   int skipGroup = bEdges.size(); // a group ID used to avoid repeating treatment of edges
 
   BEdge* be = 0; // a current edge
   int skipGroup = bEdges.size(); // a group ID used to avoid repeating treatment of edges
 

diff --git a/src/SMESH_I/SMESH_DumpPython.cxx b/src/SMESH_I/SMESH_DumpPython.cxx
index 187055df5a20356810254008776024dc9b31dc40..8b589ce00f224a3968cc5c765cce5eba6a7322c7 100644 (file)
--- a/src/SMESH_I/SMESH_DumpPython.cxx
+++ b/src/SMESH_I/SMESH_DumpPython.cxx
@@ -1297,7 +1297,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
 
   TCollection_AsciiString aLongString, aFunctionType;
   int where = 1;
 
   TCollection_AsciiString aLongString, aFunctionType;
   int where = 1;

-  set< string > functionNameSet;
+  std::set< std::string > functionNameSet;

   while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType ))
   {
     // make a python string literal
   while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType ))
   {
     // make a python string literal

diff --git a/src/SMESH_I/SMESH_Filter_i.cxx b/src/SMESH_I/SMESH_Filter_i.cxx
index 36808eed4afb03715767d29fe2b77b1c906f8ec1..42db79ef48fe71f1a01f00f9018a2d8dc9210228 100644 (file)
--- a/src/SMESH_I/SMESH_Filter_i.cxx
+++ b/src/SMESH_I/SMESH_Filter_i.cxx
@@ -1628,7 +1628,7 @@ void ConnectedElements_i::SetThreshold ( const char*
   {
   case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
     {
   {
   case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
     {

-      vector< double > xyz;
+      std::vector< double > xyz;

       char* endptr;
       do
       {
       char* endptr;
       do
       {

diff --git a/src/SMESH_I/SMESH_Gen_i.hxx b/src/SMESH_I/SMESH_Gen_i.hxx
index e2be6042d64755912c884bd8cbd906028fcf0615..b60ef8d242e9ae24470c192b94c24a0a39547018 100644 (file)
--- a/src/SMESH_I/SMESH_Gen_i.hxx
+++ b/src/SMESH_I/SMESH_Gen_i.hxx
@@ -71,16 +71,16 @@ public:
     mapIdToId.clear();
   }
   // register object in the internal map and return its id
     mapIdToId.clear();
   }
   // register object in the internal map and return its id

-  int addObject( string theIOR )
+  int addObject( std::string theIOR )

   {
     int nextId = getNextId();
     mapIdToIOR[ nextId ]  = theIOR;
     return nextId;
   }
   // find the object id in the internal map by the IOR
   {
     int nextId = getNextId();
     mapIdToIOR[ nextId ]  = theIOR;
     return nextId;
   }
   // find the object id in the internal map by the IOR

-  int findId( string theIOR )
+  int findId( std::string theIOR )

   {
   {

-    map<int, string>::iterator imap;
+    std::map<int, std::string>::iterator imap;

     for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {
       if ( imap->second == theIOR )
         return imap->first;
     for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {
       if ( imap->second == theIOR )
         return imap->first;


@@ -88,18 +88,18 @@ public:
     return 0;
   }
   // get object's IOR by id
     return 0;
   }
   // get object's IOR by id

-  string getIORbyId( const int theId )
+  std::string getIORbyId( const int theId )

   {
     if ( mapIdToIOR.find( theId ) != mapIdToIOR.end() )
       return mapIdToIOR[ theId ];
   {
     if ( mapIdToIOR.find( theId ) != mapIdToIOR.end() )
       return mapIdToIOR[ theId ];

-    return string( "" );
+    return std::string( "" );

   }
   // get object's IOR by old id
   }
   // get object's IOR by old id

-  string getIORbyOldId( const int theOldId )
+  std::string getIORbyOldId( const int theOldId )

   {
     if ( mapIdToId.find( theOldId ) != mapIdToId.end() )
       return getIORbyId( mapIdToId[ theOldId ] );
   {
     if ( mapIdToId.find( theOldId ) != mapIdToId.end() )
       return getIORbyId( mapIdToId[ theOldId ] );

-    return string( "" );
+    return std::string( "" );

   }
   // maps old object id to the new one (used when restoring data)
   void mapOldToNew( const int oldId, const int newId ) {
   }
   // maps old object id to the new one (used when restoring data)
   void mapOldToNew( const int oldId, const int newId ) {


@@ -107,7 +107,7 @@ public:
   }
   // get old id by a new one
   int getOldId( const int newId ) {
   }
   // get old id by a new one
   int getOldId( const int newId ) {

-    map<int, int>::iterator imap;
+    std::map<int, int>::iterator imap;

     for ( imap = mapIdToId.begin(); imap != mapIdToId.end(); ++imap ) {
       if ( imap->second == newId )
         return imap->first;
     for ( imap = mapIdToId.begin(); imap != mapIdToId.end(); ++imap ) {
       if ( imap->second == newId )
         return imap->first;


@@ -125,8 +125,8 @@ private:
     return id;
   }
 
     return id;
   }
 

-  map<int, string> mapIdToIOR;      // persistent-to-transient map
-  map<int, int>    mapIdToId;       // used to translate object from persistent to transient form
+  std::map<int, std::string> mapIdToIOR; // persistent-to-transient map
+  std::map<int, int>         mapIdToId;  // to translate object from persistent to transient form

 };
 
 // ===========================================================
 };
 
 // ===========================================================


@@ -568,7 +568,7 @@ public:
   typename TInterface::_var_type GetObjectByOldId( const int oldID )
   {
     if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {
   typename TInterface::_var_type GetObjectByOldId( const int oldID )
   {
     if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {

-      string ior = myStudyContext->getIORbyOldId( oldID );
+      std::string ior = myStudyContext->getIORbyOldId( oldID );

       if ( !ior.empty() )
         return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
     }
       if ( !ior.empty() )
         return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
     }


@@ -671,13 +671,13 @@ private:
   ::SMESH_Gen                    myGen;         // SMESH_Gen local implementation
 
   // hypotheses managing
   ::SMESH_Gen                    myGen;         // SMESH_Gen local implementation
 
   // hypotheses managing

-  map<string, GenericHypothesisCreator_i*> myHypCreatorMap;
+  std::map<std::string, GenericHypothesisCreator_i*> myHypCreatorMap;

 
 

-  map<int, StudyContext*>   myStudyContextMap;  // Map of study context objects
+  std::map<int, StudyContext*>   myStudyContextMap;  // Map of study context objects

 
 

-  GEOM_Client*              myShapeReader;      // Shape reader
-  SALOMEDS::Study_var       myCurrentStudy;     // Current study
-  CORBA::Boolean            myIsEmbeddedMode;   // Current mode
+  GEOM_Client*                   myShapeReader;      // Shape reader
+  SALOMEDS::Study_var            myCurrentStudy;     // Current study
+  CORBA::Boolean                 myIsEmbeddedMode;   // Current mode

 
   // Default color of groups
   std::string myDefaultGroupColor;
 
   // Default color of groups
   std::string myDefaultGroupColor;

diff --git a/src/SMESH_I/SMESH_Gen_i_1.cxx b/src/SMESH_I/SMESH_Gen_i_1.cxx
index 66422047da112e36a94284f0613a112c62d60e27..322b13d5832903f29c26d3d256d874bb6d2928a2 100644 (file)
--- a/src/SMESH_I/SMESH_Gen_i_1.cxx
+++ b/src/SMESH_I/SMESH_Gen_i_1.cxx
@@ -47,12 +47,12 @@
 
 #ifdef _DEBUG_
 static int MYDEBUG = 0;
 
 #ifdef _DEBUG_
 static int MYDEBUG = 0;

-//static int VARIABLE_DEBUG = 0;

 #else
 static int MYDEBUG = 0;
 #else
 static int MYDEBUG = 0;

-//static int VARIABLE_DEBUG = 0;

 #endif
 
 #endif
 

+using namespace std;
+

 //=============================================================================
 /*!
  *  Get...Tag [ static ]
 //=============================================================================
 /*!
  *  Get...Tag [ static ]


@@ -281,7 +281,8 @@ static SALOMEDS::SObject_ptr publish(SALOMEDS::Study_ptr   theStudy,
       SALOMEDS::SObject_wrap curObj;
       if ( theFatherObject->GetLastChildTag() > theTag )
       {
       SALOMEDS::SObject_wrap curObj;
       if ( theFatherObject->GetLastChildTag() > theTag )
       {

-        SALOMEDS::UseCaseIterator_wrap anUseCaseIter = useCaseBuilder->GetUseCaseIterator(theFatherObject);
+        SALOMEDS::UseCaseIterator_wrap
+          anUseCaseIter = useCaseBuilder->GetUseCaseIterator(theFatherObject);

         for ( ; anUseCaseIter->More(); anUseCaseIter->Next() ) {
           curObj = anUseCaseIter->Value();
           if ( curObj->Tag() > theTag  ) {
         for ( ; anUseCaseIter->More(); anUseCaseIter->Next() ) {
           curObj = anUseCaseIter->Value();
           if ( curObj->Tag() > theTag  ) {


@@ -294,21 +295,29 @@ static SALOMEDS::SObject_ptr publish(SALOMEDS::Study_ptr   theStudy,
   }
 
   SALOMEDS::GenericAttribute_wrap anAttr;
   }
 
   SALOMEDS::GenericAttribute_wrap anAttr;

-  if ( !CORBA::is_nil( theIOR )) {
+  if ( !CORBA::is_nil( theIOR ))
+  {

     anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeIOR" );
     CORBA::String_var objStr = SMESH_Gen_i::GetORB()->object_to_string( theIOR );
     SALOMEDS::AttributeIOR_wrap iorAttr = anAttr;
     anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeIOR" );
     CORBA::String_var objStr = SMESH_Gen_i::GetORB()->object_to_string( theIOR );
     SALOMEDS::AttributeIOR_wrap iorAttr = anAttr;

-    iorAttr->SetValue( objStr.in() );
-    // UnRegister() !!!
-    SALOME::GenericObj_var genObj = SALOME::GenericObj::_narrow( theIOR );
-    if ( !genObj->_is_nil() )
-      genObj->UnRegister();
+    CORBA::String_var objStrCur = iorAttr->Value();
+    bool sameIOR = ( objStrCur.in() && strcmp( objStr.in(), objStrCur.in() ) == 0 );
+    if ( !sameIOR )
+    {
+      iorAttr->SetValue( objStr.in() );
+      // UnRegister() !!!
+      SALOME::GenericObj_var genObj = SALOME::GenericObj::_narrow( theIOR );
+      if ( !genObj->_is_nil() )
+        genObj->UnRegister();
+    }

   }
   }

+

   if ( thePixMap ) {
     anAttr  = aStudyBuilder->FindOrCreateAttribute( SO, "AttributePixMap" );
     SALOMEDS::AttributePixMap_wrap pm = anAttr;
     pm->SetPixMap( thePixMap );
   }
   if ( thePixMap ) {
     anAttr  = aStudyBuilder->FindOrCreateAttribute( SO, "AttributePixMap" );
     SALOMEDS::AttributePixMap_wrap pm = anAttr;
     pm->SetPixMap( thePixMap );
   }

+

   if ( !theSelectable ) {
     anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeSelectable" );
     SALOMEDS::AttributeSelectable_wrap selAttr = anAttr;
   if ( !theSelectable ) {
     anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeSelectable" );
     SALOMEDS::AttributeSelectable_wrap selAttr = anAttr;

diff --git a/src/SMESH_I/SMESH_Group_i.cxx b/src/SMESH_I/SMESH_Group_i.cxx
index 9d3b3ee021016c8152d2542ca1f3b325bc5609b9..8bae7fb5bd72c39c7e5b62894c9a1092124a77d8 100644 (file)
--- a/src/SMESH_I/SMESH_Group_i.cxx
+++ b/src/SMESH_I/SMESH_Group_i.cxx
@@ -502,8 +502,8 @@ namespace
    */
   //================================================================================
 
    */
   //================================================================================
 

-  void getNodesOfElements(SMDS_ElemIteratorPtr        elemIt,
-                          set<const SMDS_MeshNode* >& nodes)
+  void getNodesOfElements(SMDS_ElemIteratorPtr             elemIt,
+                          std::set<const SMDS_MeshNode* >& nodes)

   {
     while ( elemIt->more() )
     {
   {
     while ( elemIt->more() )
     {


@@ -531,7 +531,7 @@ CORBA::Long SMESH_GroupBase_i::GetNumberOfNodes()
   {
     if ( myNbNodes < 0 || g->GetTic() != myGroupDSTic )
     {      
   {
     if ( myNbNodes < 0 || g->GetTic() != myGroupDSTic )
     {      

-      set<const SMDS_MeshNode* > nodes;
+      std::set<const SMDS_MeshNode* > nodes;

       getNodesOfElements( g->GetElements(), nodes );
       myNbNodes = nodes.size();
       myGroupDSTic = g->GetTic();
       getNodesOfElements( g->GetElements(), nodes );
       myNbNodes = nodes.size();
       myGroupDSTic = g->GetTic();


@@ -574,10 +574,10 @@ SMESH::long_array* SMESH_GroupBase_i::GetNodeIDs()
   SMESH::long_array_var aRes = new SMESH::long_array();
   if ( SMESHDS_GroupBase* g = GetGroupDS())
   {
   SMESH::long_array_var aRes = new SMESH::long_array();
   if ( SMESHDS_GroupBase* g = GetGroupDS())
   {

-    set<const SMDS_MeshNode* > nodes;
+    std::set<const SMDS_MeshNode* > nodes;

     getNodesOfElements( g->GetElements(), nodes );
     aRes->length( nodes.size() );
     getNodesOfElements( g->GetElements(), nodes );
     aRes->length( nodes.size() );

-    set<const SMDS_MeshNode*>::iterator nIt = nodes.begin(), nEnd = nodes.end();
+    std::set<const SMDS_MeshNode*>::iterator nIt = nodes.begin(), nEnd = nodes.end();

     for ( int i = 0; nIt != nEnd; ++nIt, ++i )
       aRes[i] = (*nIt)->GetID();
   }
     for ( int i = 0; nIt != nEnd; ++nIt, ++i )
       aRes[i] = (*nIt)->GetID();
   }


@@ -918,7 +918,7 @@ SMESH::long_array* SMESH_GroupOnFilter_i::GetMeshInfo()
 
     if ( g->GetType() != SMDSAbs_Node )
     {
 
     if ( g->GetType() != SMDSAbs_Node )
     {

-      vector< int > nbElems = static_cast< SMESHDS_GroupOnFilter* >( g )->GetMeshInfo();
+      std::vector< int > nbElems = static_cast< SMESHDS_GroupOnFilter* >( g )->GetMeshInfo();

       for ( size_t i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
         if ( i < nbElems.size() )
           aRes[i] = nbElems[ i ];
       for ( size_t i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
         if ( i < nbElems.size() )
           aRes[i] = nbElems[ i ];

diff --git a/src/SMESH_I/SMESH_Measurements_i.cxx b/src/SMESH_I/SMESH_Measurements_i.cxx
index b17fc6c4ac4775b4098b14a088a0f78e1451ab87..8da1cd7cf9c4b944f293a54e1319fa537968b978 100644 (file)
--- a/src/SMESH_I/SMESH_Measurements_i.cxx
+++ b/src/SMESH_I/SMESH_Measurements_i.cxx
@@ -221,12 +221,12 @@ static void enlargeBoundingBox(const SMDS_MeshNode* theNode,
     theMeasure.node1 = theNode->GetID();
   }
   else {
     theMeasure.node1 = theNode->GetID();
   }
   else {

-    theMeasure.minX = min( theMeasure.minX, theNode->X() );
-    theMeasure.maxX = max( theMeasure.maxX, theNode->X() );
-    theMeasure.minY = min( theMeasure.minY, theNode->Y() );
-    theMeasure.maxY = max( theMeasure.maxY, theNode->Y() );
-    theMeasure.minZ = min( theMeasure.minZ, theNode->Z() );
-    theMeasure.maxZ = max( theMeasure.maxZ, theNode->Z() );
+    theMeasure.minX = std::min( theMeasure.minX, theNode->X() );
+    theMeasure.maxX = std::max( theMeasure.maxX, theNode->X() );
+    theMeasure.minY = std::min( theMeasure.minY, theNode->Y() );
+    theMeasure.maxY = std::max( theMeasure.maxY, theNode->Y() );
+    theMeasure.minZ = std::min( theMeasure.minZ, theNode->Z() );
+    theMeasure.maxZ = std::max( theMeasure.maxZ, theNode->Z() );

   }
 }
 
   }
 }
 

diff --git a/src/SMESH_I/SMESH_MeshEditor_i.cxx b/src/SMESH_I/SMESH_MeshEditor_i.cxx
index bd08f9d67785800357512b06fb0b24fe07213f70..76a5d6d166dce560ee1999a9f2e90a9d047bf800 100644 (file)
--- a/src/SMESH_I/SMESH_MeshEditor_i.cxx
+++ b/src/SMESH_I/SMESH_MeshEditor_i.cxx
@@ -5249,10 +5249,10 @@ void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump &               theDumpPytho
 */
 //================================================================================
 
 */
 //================================================================================
 

-string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
+std::string SMESH_MeshEditor_i::generateGroupName(const std::string& thePrefix)

 {
   SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
 {
   SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();

-  set<string> groupNames;
+  set<std::string> groupNames;

 
   // Get existing group names
   for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
 
   // Get existing group names
   for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {


@@ -5265,7 +5265,7 @@ string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
   }
 
   // Find new name
   }
 
   // Find new name

-  string name = thePrefix;
+  std::string name = thePrefix;

   int index = 0;
 
   while (!groupNames.insert(name).second)
   int index = 0;
 
   while (!groupNames.insert(name).second)


@@ -5573,8 +5573,8 @@ SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
     // Create group with newly created nodes
     SMESH::long_array_var anIds = GetLastCreatedNodes();
     if (anIds->length() > 0) {
     // Create group with newly created nodes
     SMESH::long_array_var anIds = GetLastCreatedNodes();
     if (anIds->length() > 0) {

-      string anUnindexedName (theNodes->GetName());
-      string aNewName = generateGroupName(anUnindexedName + "_double");
+      std::string anUnindexedName (theNodes->GetName());
+      std::string aNewName = generateGroupName(anUnindexedName + "_double");

       aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
       aNewGroup->Add(anIds);
       pyDump << aNewGroup << " = ";
       aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
       aNewGroup->Add(anIds);
       pyDump << aNewGroup << " = ";


@@ -5672,8 +5672,8 @@ SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
     // Create group with newly created nodes
     SMESH::long_array_var anIds = GetLastCreatedNodes();
     if (anIds->length() > 0) {
     // Create group with newly created nodes
     SMESH::long_array_var anIds = GetLastCreatedNodes();
     if (anIds->length() > 0) {

-      string anUnindexedName (theNodes[0]->GetName());
-      string aNewName = generateGroupName(anUnindexedName + "_double");
+      std::string anUnindexedName (theNodes[0]->GetName());
+      std::string aNewName = generateGroupName(anUnindexedName + "_double");

       aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
       aNewGroup->Add(anIds);
       pyDump << aNewGroup << " = ";
       aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
       aNewGroup->Add(anIds);
       pyDump << aNewGroup << " = ";


@@ -5897,7 +5897,7 @@ SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
   {
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems->GetName();
   {
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems->GetName();

-    string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+    std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");

     if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();
     if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();


@@ -6129,7 +6129,7 @@ SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems
   {
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems[0]->GetName();
   {
     // Create group with newly created elements
     CORBA::String_var elemGroupName = theElems[0]->GetName();

-    string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+    std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");

     if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();
     if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
     {
       SMESH::long_array_var anIds = GetLastCreatedElems();

diff --git a/src/SMESH_I/SMESH_MeshEditor_i.hxx b/src/SMESH_I/SMESH_MeshEditor_i.hxx
index 3c36508b84597492b031d77762214bdbf76464a6..e657c5f610fd20a34c4949fa5f7a1a6df0a8ff6f 100644 (file)
--- a/src/SMESH_I/SMESH_MeshEditor_i.hxx
+++ b/src/SMESH_I/SMESH_MeshEditor_i.hxx
@@ -37,6 +37,7 @@
 #include "SMESH_PythonDump.hxx"
 #include "SMESH_MeshEditor.hxx"
 #include <list>
 #include "SMESH_PythonDump.hxx"
 #include "SMESH_MeshEditor.hxx"
 #include <list>

+#include <string>

 
 class SMESH_Mesh_i;
 
 
 class SMESH_Mesh_i;
 


@@ -897,7 +898,7 @@ private: //!< private methods
   void dumpGroupsList(SMESH::TPythonDump &        theDumpPython,
                       const SMESH::ListOfGroups * theGroupList);
 
   void dumpGroupsList(SMESH::TPythonDump &        theDumpPython,
                       const SMESH::ListOfGroups * theGroupList);
 

-  string generateGroupName(const string& thePrefix);
+  std::string generateGroupName(const std::string& thePrefix);

 
   void prepareIdSource(SMESH::SMESH_IDSource_ptr theObject);
 
 
   void prepareIdSource(SMESH::SMESH_IDSource_ptr theObject);
 

diff --git a/src/SMESH_I/SMESH_Pattern_i.cxx b/src/SMESH_I/SMESH_Pattern_i.cxx
index 511433f6fb833a7f1932a44e61672652220b9104..40d68e5b9b9e620b86daaa7b9c7cfe1bdc39cfe1 100644 (file)
--- a/src/SMESH_I/SMESH_Pattern_i.cxx
+++ b/src/SMESH_I/SMESH_Pattern_i.cxx
@@ -45,6 +45,8 @@
 #include <sstream>
 #include <set>
 
 #include <sstream>
 #include <set>
 

+using namespace std;
+

 using SMESH::TPythonDump;
 using SMESH::TVar;
 
 using SMESH::TPythonDump;
 using SMESH::TVar;
 

diff --git a/src/SMESH_I/SMESH_PreMeshInfo.cxx b/src/SMESH_I/SMESH_PreMeshInfo.cxx
index 21fe1513eef3b5612d5a5e9faadf626840060d57..0621ed9f1db69f72dcd23f813bbf9a37dbc1065b 100644 (file)
--- a/src/SMESH_I/SMESH_PreMeshInfo.cxx
+++ b/src/SMESH_I/SMESH_PreMeshInfo.cxx
@@ -54,6 +54,7 @@
 
 #include CORBA_SERVER_HEADER(SALOME_Session)
 
 
 #include CORBA_SERVER_HEADER(SALOME_Session)
 

+using namespace std;

 
 #define MYDEBUGOUT(msg) //std::cout << msg << std::endl;
 
 
 #define MYDEBUGOUT(msg) //std::cout << msg << std::endl;
 


@@ -62,7 +63,7 @@ namespace
   enum {  GroupOnFilter_OutOfDate = -1 };
 
   // a map to count not yet loaded meshes 
   enum {  GroupOnFilter_OutOfDate = -1 };
 
   // a map to count not yet loaded meshes 

-  static map< int, int > theStudyIDToMeshCounter;
+  static std::map< int, int > theStudyIDToMeshCounter;

 
   //================================================================================
   /*!
 
   //================================================================================
   /*!


@@ -72,8 +73,8 @@ namespace
 
   void meshInfoLoaded( SMESH_Mesh_i* mesh )
   {
 
   void meshInfoLoaded( SMESH_Mesh_i* mesh )
   {

-    map< int, int >::iterator id2counter =
-      theStudyIDToMeshCounter.insert( make_pair( (int) mesh->GetStudyId(), 0 )).first;
+    std::map< int, int >::iterator id2counter =
+      theStudyIDToMeshCounter.insert( std::make_pair( (int) mesh->GetStudyId(), 0 )).first;

     id2counter->second++;
   }
   //================================================================================
     id2counter->second++;
   }
   //================================================================================


@@ -88,7 +89,7 @@ namespace
   {
     if ( --theStudyIDToMeshCounter[ (int) mesh->GetStudyId() ] == 0 )
     {
   {
     if ( --theStudyIDToMeshCounter[ (int) mesh->GetStudyId() ] == 0 )
     {

-      string tmpDir = SALOMEDS_Tool::GetDirFromPath( hdfFile );
+      std::string tmpDir = SALOMEDS_Tool::GetDirFromPath( hdfFile );

 
       SALOMEDS::ListOfFileNames_var aFiles = new SALOMEDS::ListOfFileNames;
       aFiles->length(2);
 
       SALOMEDS::ListOfFileNames_var aFiles = new SALOMEDS::ListOfFileNames;
       aFiles->length(2);


@@ -109,7 +110,7 @@ namespace
 
   class SignalToGUI
   {
 
   class SignalToGUI
   {

-    string              _messagePrefix;
+    std::string         _messagePrefix;

     SALOME::Session_var _session;
   public:
     SignalToGUI( SMESH_Mesh_i* mesh )
     SALOME::Session_var _session;
   public:
     SignalToGUI( SMESH_Mesh_i* mesh )


@@ -127,7 +128,7 @@ namespace
           _messagePrefix = "SMESH/mesh_loading/";
           _messagePrefix += meshEntry.in();
 
           _messagePrefix = "SMESH/mesh_loading/";
           _messagePrefix += meshEntry.in();
 

-          string msgToGUI = _messagePrefix + "/";
+          std::string msgToGUI = _messagePrefix + "/";

           msgToGUI += SMESH_Comment( mesh->NbNodes() );
           msgToGUI += "/";
           msgToGUI += SMESH_Comment( mesh->NbElements() );
           msgToGUI += SMESH_Comment( mesh->NbNodes() );
           msgToGUI += "/";
           msgToGUI += SMESH_Comment( mesh->NbElements() );


@@ -140,7 +141,7 @@ namespace
     {
       if ( !_messagePrefix.empty() )
       {
     {
       if ( !_messagePrefix.empty() )
       {

-        string msgToGUI = _messagePrefix + "/stop";
+        std::string msgToGUI = _messagePrefix + "/stop";

         _session->emitMessageOneWay( msgToGUI.c_str());
         _messagePrefix.clear();
       }
         _session->emitMessageOneWay( msgToGUI.c_str());
         _messagePrefix.clear();
       }


@@ -173,7 +174,7 @@ namespace
     SMDS_PositionPtr vertexPosition()  const { return SMDS_PositionPtr( new SMDS_VertexPosition); }
     SMDS_PositionPtr defaultPosition() const { return SMDS_SpacePosition::originSpacePosition();  }
     typedef SMDS_PositionPtr (PositionCreator:: * FmakePos)() const;
     SMDS_PositionPtr vertexPosition()  const { return SMDS_PositionPtr( new SMDS_VertexPosition); }
     SMDS_PositionPtr defaultPosition() const { return SMDS_SpacePosition::originSpacePosition();  }
     typedef SMDS_PositionPtr (PositionCreator:: * FmakePos)() const;

-    vector<FmakePos> myFuncTable;
+    std::vector<FmakePos> myFuncTable;

   };
 
   //================================================================================
   };
 
   //================================================================================


@@ -182,12 +183,12 @@ namespace
    */
   //================================================================================
 
    */
   //================================================================================
 

-  vector<int> getSimpleSubMeshIds( SMESHDS_Mesh* meshDS, int shapeId )
+  std::vector<int> getSimpleSubMeshIds( SMESHDS_Mesh* meshDS, int shapeId )

   {
   {

-    vector<int> ids;
+    std::vector<int> ids;

 
 

-    list<TopoDS_Shape> shapeQueue( 1, meshDS->IndexToShape( shapeId ));
-    list<TopoDS_Shape>::iterator shape = shapeQueue.begin();
+    std::list<TopoDS_Shape> shapeQueue( 1, meshDS->IndexToShape( shapeId ));
+    std::list<TopoDS_Shape>::iterator shape = shapeQueue.begin();

     for ( ; shape != shapeQueue.end(); ++shape )
     {
       if ( shape->IsNull() ) continue;
     for ( ; shape != shapeQueue.end(); ++shape )
     {
       if ( shape->IsNull() ) continue;


@@ -222,10 +223,10 @@ namespace
    */
   //================================================================================
 
    */
   //================================================================================
 

-  typedef map< MED::EGeometrieElement, SMDSAbs_EntityType > Tmed2smeshElemTypeMap;
+  typedef std::map< MED::EGeometrieElement, SMDSAbs_EntityType > Tmed2smeshElemTypeMap;

   const Tmed2smeshElemTypeMap& med2smeshElemTypeMap()
   {
   const Tmed2smeshElemTypeMap& med2smeshElemTypeMap()
   {

-    static map< MED::EGeometrieElement, SMDSAbs_EntityType> med2smeshTypes;
+    static Tmed2smeshElemTypeMap med2smeshTypes;

     if ( med2smeshTypes.empty() )
     {
       for  ( int iG = 0; iG < SMDSEntity_Last; ++iG )
     if ( med2smeshTypes.empty() )
     {
       for  ( int iG = 0; iG < SMDSEntity_Last; ++iG )


@@ -233,7 +234,7 @@ namespace
         SMDSAbs_EntityType    smdsType = (SMDSAbs_EntityType) iG;
         MED::EGeometrieElement medType =
           (MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );
         SMDSAbs_EntityType    smdsType = (SMDSAbs_EntityType) iG;
         MED::EGeometrieElement medType =
           (MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );

-        med2smeshTypes.insert( make_pair( medType, smdsType ));
+        med2smeshTypes.insert( std::make_pair( medType, smdsType ));

       }
     }
     return med2smeshTypes;
       }
     }
     return med2smeshTypes;


@@ -254,7 +255,7 @@ namespace
     // change at insertion of new items in the middle.
     //const vector<MED::EGeometrieElement>& medTypes = mesh2medElemType();
 
     // change at insertion of new items in the middle.
     //const vector<MED::EGeometrieElement>& medTypes = mesh2medElemType();
 

-    vector<int> data;
+    std::vector<int> data;

 
     for ( size_t i = 0; i < meshInfo->length(); ++i )
       if ( meshInfo[i] > 0 )
 
     for ( size_t i = 0; i < meshInfo->length(); ++i )
       if ( meshInfo[i] > 0 )


@@ -298,7 +299,7 @@ void SMESH_PreMeshInfo::hdf2meshInfo( const std::string& name,
     // // array->GetDim( datasetSize );
     // int size = dataset->GetSize();
 
     // // array->GetDim( datasetSize );
     // int size = dataset->GetSize();
 

-    vector<int> info( SMDSEntity_Last * 2, 0 );
+    std::vector<int> info( SMDSEntity_Last * 2, 0 );

     dataset->ReadFromDisk( &info[0] );
     dataset->CloseOnDisk();
 
     dataset->ReadFromDisk( &info[0] );
     dataset->CloseOnDisk();
 


@@ -429,7 +430,7 @@ bool SMESH_PreMeshInfo::readPreInfoFromHDF()
         group_i->changePreMeshInfo() = newInstance();
         if ( SMESHDS_GroupBase* group = group_i->GetGroupDS() )
         {
         group_i->changePreMeshInfo() = newInstance();
         if ( SMESHDS_GroupBase* group = group_i->GetGroupDS() )
         {

-          const string name = group->GetStoreName();
+          const std::string name = group->GetStoreName();

           group_i->changePreMeshInfo()->hdf2meshInfo( name, infoHdfGroup );
         }
       }
           group_i->changePreMeshInfo()->hdf2meshInfo( name, infoHdfGroup );
         }
       }


@@ -499,7 +500,7 @@ void SMESH_PreMeshInfo::readGroupInfo()
   if ( _mesh->_mapGroups.empty() ) return;
 
   // make SMESH_PreMeshInfo of groups
   if ( _mesh->_mapGroups.empty() ) return;
 
   // make SMESH_PreMeshInfo of groups

-  map< string, SMESH_PreMeshInfo* > name2GroupInfo;
+  map< std::string, SMESH_PreMeshInfo* > name2GroupInfo;

   map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i2group = _mesh->_mapGroups.begin();
   for ( ; i2group != _mesh->_mapGroups.end(); ++i2group )
   {
   map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i2group = _mesh->_mapGroups.begin();
   for ( ; i2group != _mesh->_mapGroups.end(); ++i2group )
   {


@@ -510,8 +511,8 @@ void SMESH_PreMeshInfo::readGroupInfo()
       group_i->changePreMeshInfo() = info;
       if ( SMESHDS_Group* group = dynamic_cast< SMESHDS_Group* >( group_i->GetGroupDS() ))
       {
       group_i->changePreMeshInfo() = info;
       if ( SMESHDS_Group* group = dynamic_cast< SMESHDS_Group* >( group_i->GetGroupDS() ))
       {

-        string name = group->GetStoreName();
-        name2GroupInfo.insert( make_pair( name, info ));
+        std::string name = group->GetStoreName();
+        name2GroupInfo.insert( std::make_pair( name, info ));

         info->_isInfoOk = true;
       }
     }
         info->_isInfoOk = true;
       }
     }


@@ -534,8 +535,8 @@ void SMESH_PreMeshInfo::readGroupInfo()
     vector< SMESH_PreMeshInfo* >& grInfoVec = famId2grInfo[ medFamInfo->GetId() ];
     for ( int iG = 0; iG < nbGroups; ++iG )
     {
     vector< SMESH_PreMeshInfo* >& grInfoVec = famId2grInfo[ medFamInfo->GetId() ];
     for ( int iG = 0; iG < nbGroups; ++iG )
     {

-      const string grName = medFamInfo->GetGroupName( iG );
-      map< string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.find( grName );
+      const std::string grName = medFamInfo->GetGroupName( iG );
+      map< std::string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.find( grName );

       if ( n2i != name2GroupInfo.end() )
         grInfoVec.push_back( n2i->second );
     }
       if ( n2i != name2GroupInfo.end() )
         grInfoVec.push_back( n2i->second );
     }


@@ -560,14 +561,14 @@ void SMESH_PreMeshInfo::readGroupInfo()
         f2infos = famId2grInfo.find( famNums[i] );
         if ( f2infos == famId2grInfo.end() )
           f2infos = famId2grInfo.insert
         f2infos = famId2grInfo.find( famNums[i] );
         if ( f2infos == famId2grInfo.end() )
           f2infos = famId2grInfo.insert

-            ( make_pair( famNums[i], vector< SMESH_PreMeshInfo*>())).first;
+            ( std::make_pair( famNums[i], vector< SMESH_PreMeshInfo*>())).first;

       }
       vector< SMESH_PreMeshInfo* >& infoVec = f2infos->second ;
       for ( size_t j = 0; j < infoVec.size(); ++j )
         infoVec[j]->_elemCounter++;
     }
     // pass _elemCounter to a real elem type
       }
       vector< SMESH_PreMeshInfo* >& infoVec = f2infos->second ;
       for ( size_t j = 0; j < infoVec.size(); ++j )
         infoVec[j]->_elemCounter++;
     }
     // pass _elemCounter to a real elem type

-    map< string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.begin();
+    map< std::string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.begin();

     for ( ; n2i != name2GroupInfo.end(); ++n2i )
     {
       SMESH_PreMeshInfo* info = n2i->second;
     for ( ; n2i != name2GroupInfo.end(); ++n2i )
     {
       SMESH_PreMeshInfo* info = n2i->second;


@@ -618,7 +619,7 @@ void SMESH_PreMeshInfo::readSubMeshInfo()
 
       for ( int isNode = 0; isNode < 2; ++isNode )
       {
 
       for ( int isNode = 0; isNode < 2; ++isNode )
       {

-        string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
+        std::string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");

         if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
         {
           // read sub-mesh id of all nodes or elems
         if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
         {
           // read sub-mesh id of all nodes or elems


@@ -893,7 +894,7 @@ void SMESH_PreMeshInfo::readSubMeshes(DriverMED_R_SMESHDS_Mesh* reader) const
       SMDS_ElemIteratorPtr eIt = meshDS->elementsIterator();
       for ( int isNode = 0; isNode < 2; ++isNode )
       {
       SMDS_ElemIteratorPtr eIt = meshDS->elementsIterator();
       for ( int isNode = 0; isNode < 2; ++isNode )
       {

-        string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
+        std::string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");

         if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
         {
           HDFdataset* aDataset = new HDFdataset( (char*) aDSName.c_str(), aGroup );
         if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
         {
           HDFdataset* aDataset = new HDFdataset( (char*) aDSName.c_str(), aGroup );

diff --git a/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx b/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
index 20e7048b9ab5a4f5953c7c9ece6ebabe149d171e..e59c60886e9b2b4a4b78638f312319d48f0e99b0 100644 (file)
--- a/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
+++ b/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
@@ -58,6 +58,7 @@
 #include <set>
 #include <vector>
 
 #include <set>
 #include <vector>
 

+using namespace std;

 
 #ifdef _DEBUG_
 // #define DEB_FACES
 
 #ifdef _DEBUG_
 // #define DEB_FACES

diff --git a/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx b/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
index 5545f781a7ff9655a4e5f882176ca84cefde6780..ac251c03dd970d3792c360f7ca531add41e4b628 100644 (file)
--- a/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
+++ b/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
@@ -57,15 +57,15 @@ public:
 
 private:
 
 
 private:
 

-  bool findBoxFaces( const TopoDS_Shape&    shape,
-                     list< _QuadFaceGrid >& boxFaceContainer,
-                     SMESH_Mesh&            mesh,
-                     _QuadFaceGrid * &      fBottom,
-                     _QuadFaceGrid * &      fTop,
-                     _QuadFaceGrid * &      fFront,
-                     _QuadFaceGrid * &      fBack,
-                     _QuadFaceGrid * &      fLeft,
-                     _QuadFaceGrid * &      fRight);
+  bool findBoxFaces( const TopoDS_Shape&         shape,
+                     std::list< _QuadFaceGrid >& boxFaceContainer,
+                     SMESH_Mesh&                 mesh,
+                     _QuadFaceGrid * &           fBottom,
+                     _QuadFaceGrid * &           fTop,
+                     _QuadFaceGrid * &           fFront,
+                     _QuadFaceGrid * &           fBack,
+                     _QuadFaceGrid * &           fLeft,
+                     _QuadFaceGrid * &           fRight);

 };
 
 #endif
 };
 
 #endif

diff --git a/src/StdMeshers/StdMeshers_FaceSide.cxx b/src/StdMeshers/StdMeshers_FaceSide.cxx
index 3849040e995afa5de3d232518f36b7dd3410fdac..d0c2589365774ee35475a4941d080bb644a96508 100644 (file)
--- a/src/StdMeshers/StdMeshers_FaceSide.cxx
+++ b/src/StdMeshers/StdMeshers_FaceSide.cxx
@@ -56,6 +56,8 @@
 
 #include "utilities.h"
 
 
 #include "utilities.h"
 

+using namespace std;
+

 //================================================================================
 /*!
  * \brief Constructor of a side of one edge
 //================================================================================
 /*!
  * \brief Constructor of a side of one edge


@@ -71,7 +73,7 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&   theFace,
                                          const bool           theIgnoreMediumNodes,
                                          SMESH_ProxyMesh::Ptr theProxyMesh)
 {
                                          const bool           theIgnoreMediumNodes,
                                          SMESH_ProxyMesh::Ptr theProxyMesh)
 {

-  list<TopoDS_Edge> edges(1,theEdge);
+  std::list<TopoDS_Edge> edges(1,theEdge);

   *this = StdMeshers_FaceSide( theFace, edges, theMesh, theIsForward,
                                theIgnoreMediumNodes, theProxyMesh );
 }
   *this = StdMeshers_FaceSide( theFace, edges, theMesh, theIsForward,
                                theIgnoreMediumNodes, theProxyMesh );
 }


@@ -82,12 +84,12 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&   theFace,
  */
 //================================================================================
 
  */
 //================================================================================
 

-StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&   theFace,
-                                         list<TopoDS_Edge>&   theEdges,
-                                         SMESH_Mesh*          theMesh,
-                                         const bool           theIsForward,
-                                         const bool           theIgnoreMediumNodes,
-                                         SMESH_ProxyMesh::Ptr theProxyMesh)
+StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&      theFace,
+                                         std::list<TopoDS_Edge>& theEdges,
+                                         SMESH_Mesh*             theMesh,
+                                         const bool              theIsForward,
+                                         const bool              theIgnoreMediumNodes,
+                                         SMESH_ProxyMesh::Ptr    theProxyMesh)

 {
   int nbEdges = theEdges.size();
   myEdge.resize      ( nbEdges );
 {
   int nbEdges = theEdges.size();
   myEdge.resize      ( nbEdges );


@@ -112,7 +114,7 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&   theFace,
   SMESHDS_Mesh* meshDS = myProxyMesh->GetMeshDS();
 
   int nbDegen = 0;
   SMESHDS_Mesh* meshDS = myProxyMesh->GetMeshDS();
 
   int nbDegen = 0;

-  list<TopoDS_Edge>::iterator edge = theEdges.begin();
+  std::list<TopoDS_Edge>::iterator edge = theEdges.begin();

   for ( int index = 0; edge != theEdges.end(); ++index, ++edge )
   {
     int i = theIsForward ? index : nbEdges-index-1;
   for ( int index = 0; edge != theEdges.end(); ++index, ++edge )
   {
     int i = theIsForward ? index : nbEdges-index-1;


@@ -302,8 +304,8 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec&     theSideNodes,
  */
 //================================================================================
 
  */
 //================================================================================
 

-const vector<UVPtStruct>& StdMeshers_FaceSide::GetUVPtStruct(bool   isXConst,
-                                                             double constValue) const
+const std::vector<UVPtStruct>& StdMeshers_FaceSide::GetUVPtStruct(bool   isXConst,
+                                                                  double constValue) const

 {
   if ( myPoints.empty() )
   {
 {
   if ( myPoints.empty() )
   {

diff --git a/src/StdMeshers/StdMeshers_Geometric1D.cxx b/src/StdMeshers/StdMeshers_Geometric1D.cxx
index dd77350f756351d7101d9d17dd1ee51c4e7d12b3..031fd7ea1cf5a720d674eeab0a020f16f0b442c3 100644 (file)
--- a/src/StdMeshers/StdMeshers_Geometric1D.cxx
+++ b/src/StdMeshers/StdMeshers_Geometric1D.cxx
@@ -166,7 +166,7 @@ bool StdMeshers_Geometric1D::SetParametersByMesh(const SMESH_Mesh*   theMesh,
     const TopoDS_Edge& edge = TopoDS::Edge( edgeMap( i ));
     BRepAdaptor_Curve C( edge );
 
     const TopoDS_Edge& edge = TopoDS::Edge( edgeMap( i ));
     BRepAdaptor_Curve C( edge );
 

-    vector< double > params;
+    std::vector< double > params;

     if ( SMESH_Algo::GetNodeParamOnEdge( theMesh->GetMeshDS(), edge, params ))
     {
       nbEdges++;
     if ( SMESH_Algo::GetNodeParamOnEdge( theMesh->GetMeshDS(), edge, params ))
     {
       nbEdges++;

diff --git a/src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx b/src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
index 6f87ebf4a83cc20075cf4fa620adab9e14cf3dd7..5cd779b75f3461d8a891f41ebf06dafd32f539c8 100644 (file)
--- a/src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
+++ b/src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
@@ -33,6 +33,8 @@
 
 #include <limits>
 
 
 #include <limits>
 

+using namespace std;
+

 // Define error message and _MYDEBUG_ if needed
 #ifdef _DEBUG_
 #define BAD_MESH_ERR \
 // Define error message and _MYDEBUG_ if needed
 #ifdef _DEBUG_
 #define BAD_MESH_ERR \

diff --git a/src/StdMeshers/StdMeshers_Prism_3D.hxx b/src/StdMeshers/StdMeshers_Prism_3D.hxx
index 0a24284016a0edcaacbe61ab6ff731be9cbb679e..9788b64a115e45cf279cd02b4ac9364f3600bd6e 100644 (file)
--- a/src/StdMeshers/StdMeshers_Prism_3D.hxx
+++ b/src/StdMeshers/StdMeshers_Prism_3D.hxx
@@ -270,7 +270,7 @@ private:
     TParam2ColumnMap*               myParamToColumnMap;
     PSurface                        mySurface;
     TopoDS_Edge                     myBaseEdge;
     TParam2ColumnMap*               myParamToColumnMap;
     PSurface                        mySurface;
     TopoDS_Edge                     myBaseEdge;

-    map< int, PSurface >            myShapeID2Surf;
+    std::map< int, PSurface >       myShapeID2Surf;

     // first and last normalized params and orientaion for each component or it-self
     std::vector< std::pair< double, double> > myParams; // select my columns in myParamToColumnMap
     bool                            myIsForward;
     // first and last normalized params and orientaion for each component or it-self
     std::vector< std::pair< double, double> > myParams; // select my columns in myParamToColumnMap
     bool                            myIsForward;

diff --git a/src/StdMeshers/StdMeshers_Projection_3D.cxx b/src/StdMeshers/StdMeshers_Projection_3D.cxx
index d8bce83cd0f1c38568cee8cfb8d72067e6736b6d..f260a2d6ff12910a6beea50bfc04d7fdf5e05eea 100644 (file)
--- a/src/StdMeshers/StdMeshers_Projection_3D.cxx
+++ b/src/StdMeshers/StdMeshers_Projection_3D.cxx
@@ -57,6 +57,7 @@
 
 namespace TAssocTool = StdMeshers_ProjectionUtils;
 
 
 namespace TAssocTool = StdMeshers_ProjectionUtils;
 

+using namespace std;

 
 //=======================================================================
 //function : StdMeshers_Projection_3D
 
 //=======================================================================
 //function : StdMeshers_Projection_3D

diff --git a/src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx b/src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
index 55e0d19ab892068571b2b03d540d079dd03b719a..acd20284680a90ed6ab0b414249abb79a788b20c 100644 (file)
--- a/src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
+++ b/src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
@@ -61,6 +61,8 @@
 #include <list>
 #include <vector>
 
 #include <list>
 #include <vector>
 

+using namespace std;
+

 //================================================================================
 /*!
  * \brief 1D algo
 //================================================================================
 /*!
  * \brief 1D algo

diff --git a/src/StdMeshers/StdMeshers_Quadrangle_2D.hxx b/src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
index 460a5e4ab7fbbd948b0f064face9a77f1f42be1b..936a5e1c235f57c45faf28eb85a7c3325064f323 100644 (file)
--- a/src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
+++ b/src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
@@ -82,7 +82,7 @@ struct FaceQuadStruct
       return GetUVPtStruct()[ to-nbNodeOut-(IsReversed() ? -1 : +1)];
     }
     // some sortcuts
       return GetUVPtStruct()[ to-nbNodeOut-(IsReversed() ? -1 : +1)];
     }
     // some sortcuts

-    const vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
+    const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const

     { return nbNodeOut ?
         grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
         grid->GetUVPtStruct( isXConst, constValue );
     { return nbNodeOut ?
         grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
         grid->GetUVPtStruct( isXConst, constValue );

diff --git a/src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx b/src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
index 9036dc18bc6965b99d2c8df29a44324f40a1a1e9..decbc2a6212fd0a1a20bfc67dc0930debc355516 100644 (file)
--- a/src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
+++ b/src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
@@ -38,7 +38,7 @@ StdMeshers_SegmentAroundVertex_0D::StdMeshers_SegmentAroundVertex_0D
   :SMESH_0D_Algo(hypId, studyId, gen)
 {
   _name = "SegmentAroundVertex_0D";
   :SMESH_0D_Algo(hypId, studyId, gen)
 {
   _name = "SegmentAroundVertex_0D";

-  // it is assigned to vertices but influence a state of EDGE submeshes 
+  // it is assigned to vertices but influence a state of EDGE submeshes

   _shapeType = (1 << TopAbs_VERTEX);    // 1 bit per shape type
 
   _compatibleHypothesis.push_back("SegmentLengthAroundVertex");
   _shapeType = (1 << TopAbs_VERTEX);    // 1 bit per shape type
 
   _compatibleHypothesis.push_back("SegmentLengthAroundVertex");


@@ -55,16 +55,17 @@ StdMeshers_SegmentAroundVertex_0D::~StdMeshers_SegmentAroundVertex_0D()
 
 //=======================================================================
 //function : CheckHypothesis
 
 //=======================================================================
 //function : CheckHypothesis

-//purpose  : 
+//purpose  :

 //=======================================================================
 
 //=======================================================================
 

-bool StdMeshers_SegmentAroundVertex_0D::CheckHypothesis(SMESH_Mesh&                          aMesh,
-                                                        const TopoDS_Shape&                  aShape,
-                                                        SMESH_Hypothesis::Hypothesis_Status& aStatus)
+bool StdMeshers_SegmentAroundVertex_0D::
+CheckHypothesis(SMESH_Mesh&                          aMesh,
+                const TopoDS_Shape&                  aShape,
+                SMESH_Hypothesis::Hypothesis_Status& aStatus)

 {
 {

-  list <const SMESHDS_Hypothesis * >::const_iterator itl;
+  std::list <const SMESHDS_Hypothesis * >::const_iterator itl;

 
 

-  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+  const std::list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);

   if ( hyps.size() == 0 )
   {
     aStatus = SMESH_Hypothesis::HYP_MISSING;
   if ( hyps.size() == 0 )
   {
     aStatus = SMESH_Hypothesis::HYP_MISSING;


@@ -84,7 +85,7 @@ bool StdMeshers_SegmentAroundVertex_0D::CheckHypothesis(SMESH_Mesh&
 
 //=======================================================================
 //function : Compute
 
 //=======================================================================
 //function : Compute

-//purpose  : 
+//purpose  :

 //=======================================================================
 
 bool StdMeshers_SegmentAroundVertex_0D::Compute(SMESH_Mesh&, const TopoDS_Shape&)
 //=======================================================================
 
 bool StdMeshers_SegmentAroundVertex_0D::Compute(SMESH_Mesh&, const TopoDS_Shape&)

diff --git a/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx
index 9ca0a8ee8e58b6975e7fb2b0522aef0d6d91d10b..0ea622706fb6b591d68f62972a2e7c0eef5b3b7b 100644 (file)
--- a/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx
+++ b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx
@@ -178,8 +178,8 @@ void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_arra
                                                         CORBA::Short               axis)
   throw (SALOME::SALOME_Exception)
 {
                                                         CORBA::Short               axis)
   throw (SALOME::SALOME_Exception)
 {

-  vector<string> funVec;
-  vector<double> pointVec;
+  std::vector<std::string> funVec;
+  std::vector<double>      pointVec;

   _array2vec( spaceFunctions, funVec, (const char*) );
   _array2vec( internalPoints, pointVec, );
 
   _array2vec( spaceFunctions, funVec, (const char*) );
   _array2vec( internalPoints, pointVec, );
 


@@ -209,8 +209,8 @@ void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out
 {
   ASSERT( myBaseImpl );
   try {
 {
   ASSERT( myBaseImpl );
   try {

-    vector<string> funVec;
-    vector<double> pointVec;
+    std::vector<std::string> funVec;
+    std::vector<double>      pointVec;

     this->GetImpl()->GetGridSpacing( funVec, pointVec, axis );
 
     xSpaceFunctions = new SMESH::string_array();
     this->GetImpl()->GetGridSpacing( funVec, pointVec, axis );
 
     xSpaceFunctions = new SMESH::string_array();


@@ -394,8 +394,8 @@ StdMeshers_CartesianParameters3D_i::ComputeCoordinates(CORBA::Double
                                                        const char*                axisName )
   throw (SALOME::SALOME_Exception)
 {
                                                        const char*                axisName )
   throw (SALOME::SALOME_Exception)
 {

-  vector<string> xFuns;
-  vector<double> xPoints, coords;
+  std::vector<std::string> xFuns;
+  std::vector<double>      xPoints, coords;

   _array2vec( spaceFuns, xFuns, (const char*) );
   _array2vec( points, xPoints, );
 
   _array2vec( spaceFuns, xFuns, (const char*) );
   _array2vec( points, xPoints, );
 

diff --git a/src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx b/src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
index ed0ce004c1b7849a666cb3ba819981d1a161e53d..8120ca384e95c339aee8717a4c87c896980bb856 100644 (file)
--- a/src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
+++ b/src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
@@ -111,7 +111,7 @@ public:
       std::string str;
       if (stream >> str) {
         if ( StudyContext* myStudyContext = gen->GetCurrentStudyContext() ) {
       std::string str;
       if (stream >> str) {
         if ( StudyContext* myStudyContext = gen->GetCurrentStudyContext() ) {

-          string ior = myStudyContext->getIORbyOldId( atoi( str.c_str() ));
+          std::string ior = myStudyContext->getIORbyOldId( atoi( str.c_str() ));

           if ( !ior.empty() )
              return TInterface::_narrow(gen->GetORB()->string_to_object( ior.c_str() ));
         }
           if ( !ior.empty() )
              return TInterface::_narrow(gen->GetORB()->string_to_object( ior.c_str() ));
         }

diff --git a/src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx b/src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx
index 13e86c06a6a3527919727de9941621f3e396aaf8..a059ff39e378137c2e8901e4b5202d007e8dc44f 100644 (file)
--- a/src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx
+++ b/src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx
@@ -79,7 +79,7 @@ void StdMeshers_Reversible1D_i::SetReversedEdges( const SMESH::long_array& theId
 
 void StdMeshers_Reversible1D_i::SetObjectEntry( const char* theEntry )
 {
 
 void StdMeshers_Reversible1D_i::SetObjectEntry( const char* theEntry )
 {

-  string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
+  std::string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping

   try {
     this->GetImpl()->SetObjectEntry( entry.c_str() );
     // Update Python script
   try {
     this->GetImpl()->SetObjectEntry( entry.c_str() );
     // Update Python script