*** empty log message ***

diff --git a/src/SMESH/SMESH_Block.hxx b/src/SMESH/SMESH_Block.hxx
index c5bbc1e2f6561a448fec1b44dd433e362c18a609..9486c03f946a3284eef93d58b83afccd7ce0f437 100644 (file)
--- a/src/SMESH/SMESH_Block.hxx
+++ b/src/SMESH/SMESH_Block.hxx
@@ -115,10 +115,10 @@ class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
   // ShapeIndex( ID_Ex00 ) == 0
   // ShapeIndex( ID_Ex10 ) == 1
 
-  static void GetFaceEdgesIDs (const int faceID, vector< int >& edgeVec );
+  static void GetFaceEdgesIDs (const int faceID, std::vector< int >& edgeVec );
   // return edges IDs of a face in the order u0, u1, 0v, 1v
 
-  static void GetEdgeVertexIDs (const int edgeID, vector< int >& vertexVec );
+  static void GetEdgeVertexIDs (const int edgeID, std::vector< int >& vertexVec );
   // return vertex IDs of an edge
 
   static int GetCoordIndOnEdge (const int theEdgeID)
@@ -136,7 +136,7 @@ class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
   static int GetShapeIDByParams ( const gp_XYZ& theParams );
   // define an id of the block sub-shape by point parameters
 
-  static ostream& DumpShapeID (const int theBlockShapeID, ostream& stream);
+  static std::ostream& DumpShapeID (const int theBlockShapeID, std::ostream& stream);
   // DEBUG: dump an id of a block sub-shape
 
 
@@ -161,7 +161,7 @@ class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
   bool LoadMeshBlock(const SMDS_MeshVolume*        theVolume,
                      const int                     theNode000Index,
                      const int                     theNode001Index,
-                     vector<const SMDS_MeshNode*>& theOrderedNodes);
+                     std::vector<const SMDS_MeshNode*>& theOrderedNodes);
   // prepare to work with theVolume and
   // return nodes in theVolume corners in the order of TShapeID enum
 
@@ -225,7 +225,7 @@ public:
   // return coordinates of a point in shell
 
   static bool ShellPoint(const gp_XYZ&         theParams,
-                         const vector<gp_XYZ>& thePointOnShape,
+                         const std::vector<gp_XYZ>& thePointOnShape,
                          gp_XYZ&               thePoint );
   // computes coordinates of a point in shell by points on sub-shapes
   // and point parameters.
@@ -377,7 +377,7 @@ public:
   gp_XYZ   myParam; // the best parameters guess
   double   myValues[ 4 ]; // values computed at myParam: square distance and 3 derivatives
 
-  typedef pair<gp_XYZ,gp_XYZ> TxyzPair;
+  typedef std::pair<gp_XYZ,gp_XYZ> TxyzPair;
   TxyzPair my3x3x3GridNodes[ 27 ]; // to compute the first param guess
   bool     myGridComputed;
 };

diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx
index 0b361a52ba302c4eb2285dee267a39119f3fe326..dc852beed7f4e81da2db4263d4bba7bcbe9a7f0c 100644 (file)
--- a/src/SMESH/SMESH_Mesh.cxx
+++ b/src/SMESH/SMESH_Mesh.cxx
@@ -109,7 +109,7 @@ SMESH_Mesh::~SMESH_Mesh()
   INFOS("SMESH_Mesh::~SMESH_Mesh");
 
   // delete groups
-  map < int, SMESH_Group * >::iterator itg;
+  std::map < int, SMESH_Group * >::iterator itg;
   for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
     SMESH_Group *aGroup = (*itg).second;
     delete aGroup;
@@ -134,12 +134,12 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
   {
     // removal of a shape to mesh, delete objects referring to sub-shapes:
     // - sub-meshes
-    map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
+    std::map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
     for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
       delete i_sm->second;
     _mapSubMesh.clear();
     //  - groups on geometry
-    map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
+    std::map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
     while ( i_gr != _mapGroup.end() ) {
       if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
         _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
@@ -281,10 +281,10 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
   }
 
   // Reading groups (sub-meshes are out of scope of MED import functionality)
-  list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
+  std::list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
   if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size()); 
   int anId;
-  list<TNameAndType>::iterator name_type = aGroupNames.begin();
+  std::list<TNameAndType>::iterator name_type = aGroupNames.begin();
   for ( ; name_type != aGroupNames.end(); name_type++ ) {
     SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId );
     if ( aGroup ) {
@@ -534,7 +534,7 @@ SMESH_Hypothesis::Hypothesis_Status
  */
 //=============================================================================
 
-const list<const SMESHDS_Hypothesis*>&
+const std::list<const SMESHDS_Hypothesis*>&
 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
   throw(SALOME_Exception)
 {
@@ -557,8 +557,8 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubS
                                                    const bool              andAncestors) const
 {
   {
-    const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
-    list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+    const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+    std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
     for ( ; hyp != hypList.end(); hyp++ ) {
       const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
       if ( aFilter.IsOk( h, aSubShape))
@@ -570,8 +570,8 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubS
     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
     for (; it.More(); it.Next() )
     {
-      const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
-      list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+      const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
+      std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
       for ( ; hyp != hypList.end(); hyp++ ) {
         const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
         if (aFilter.IsOk( h, it.Value() ))
@@ -605,7 +605,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
   bool mainHypFound = false;
 
   // fill in hypTypes
-  list<const SMESHDS_Hypothesis*>::const_iterator hyp;
+  std::list<const SMESHDS_Hypothesis*>::const_iterator hyp;
   for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) {
     if ( hypTypes.insert( (*hyp)->GetName() ).second )
       nbHyps++;
@@ -615,7 +615,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
 
   // get hypos from aSubShape
   {
-    const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+    const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
     for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
       if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) &&
            ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
@@ -637,7 +637,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
     {
      if ( !map.Add( it.Value() ))
         continue;
-      const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
+      const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
       for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
         if (aFilter.IsOk( cSMESH_Hyp( *hyp ), it.Value() ) &&
             ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
@@ -659,7 +659,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
  */
 //=============================================================================
 
-const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
+const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
@@ -757,19 +757,19 @@ throw(SALOME_Exception)
  */
 //================================================================================
 
-list<SMESH_subMesh*>
+std::list<SMESH_subMesh*>
 SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
   throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
-  list<SMESH_subMesh*> found;
+  std::list<SMESH_subMesh*> found;
 
   SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape);
   if ( !subMesh )
     return found;
 
   // submeshes of groups have max IDs, so search from the map end
-  map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
+  std::map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
   for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) {
     SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS();
     if ( ds && ds->IsComplexSubmesh() ) {
@@ -927,9 +927,9 @@ bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
 bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
 {
   set<string> aGroupNames;
-  for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+  for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
     SMESH_Group* aGroup = it->second;
-    string aGroupName = aGroup->GetName();
+    std::string aGroupName = aGroup->GetName();
     aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
     if (!aGroupNames.insert(aGroupName).second)
       return true;
@@ -967,7 +967,7 @@ void SMESH_Mesh::ExportMED(const char *file,
   set<string> aGroupNames;
   char aString [256];
   int maxNbIter = 10000; // to guarantee cycle finish
-  for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+  for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
     SMESH_Group*       aGroup   = it->second;
     SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
     if ( aGroupDS ) {
@@ -1007,11 +1007,11 @@ void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
   myWriter.SetMeshId(_idDoc);
   //  myWriter.SetGroups(_mapGroup);
 
-  for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+  for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
     SMESH_Group*       aGroup   = it->second;
     SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
     if ( aGroupDS ) {
-      string aGroupName = aGroup->GetName();
+      std::string aGroupName = aGroup->GetName();
       aGroupDS->SetStoreName( aGroupName.c_str() );
       myWriter.AddGroup( aGroupDS );
     }
@@ -1261,10 +1261,10 @@ SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
  */
 //=============================================================================
 
-list<int> SMESH_Mesh::GetGroupIds() const
+std::list<int> SMESH_Mesh::GetGroupIds() const
 {
-  list<int> anIds;
-  for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
+  std::list<int> anIds;
+  for ( std::map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
     anIds.push_back( it->first );
   
   return anIds;
@@ -1329,7 +1329,7 @@ ostream& SMESH_Mesh::Dump(ostream& save)
       save << clause << ".1) Number of " << orderStr << " triangles:  \t" << nb3 << endl;
       save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
       if ( nb3 + nb4 !=  NbFaces(order) ) {
-        map<int,int> myFaceMap;
+        std::map<int,int> myFaceMap;
         SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
         while( itFaces->more( ) ) {
           int nbNodes = itFaces->next()->NbNodes();
@@ -1354,7 +1354,7 @@ ostream& SMESH_Mesh::Dump(ostream& save)
       save << clause << ".3) Number of " << orderStr << " prisms:      \t" << nb6 << endl;
       save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl;
       if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) {
-        map<int,int> myVolumesMap;
+        std::map<int,int> myVolumesMap;
         SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
         while( itVolumes->more( ) ) {
           int nbNodes = itVolumes->next()->NbNodes();

diff --git a/src/SMESH/SMESH_Mesh.hxx b/src/SMESH/SMESH_Mesh.hxx
index 3005f678e0b77f28527105a6905d2a5d9093f69c..c0dc3e4f758f6cecd2d01ddfe286fd9cce4bd7b8 100644 (file)
--- a/src/SMESH/SMESH_Mesh.hxx
+++ b/src/SMESH/SMESH_Mesh.hxx
@@ -244,8 +244,8 @@ protected:
   std::list <SMESH_subMesh*> _subMeshesUsingHypothesisList;
   SMESHDS_Document *         _myDocument;
   SMESHDS_Mesh *             _myMeshDS;
-  map <int, SMESH_subMesh *> _mapSubMesh;
-  map <int, SMESH_Group *>   _mapGroup;
+  std::map <int, SMESH_subMesh*> _mapSubMesh;
+  std::map <int, SMESH_Group*>   _mapGroup;
   SMESH_Gen *                _gen;
 
   bool                       _isAutoColor;

diff --git a/src/SMESH/SMESH_MeshEditor.hxx b/src/SMESH/SMESH_MeshEditor.hxx
index fd5facec2e6ad444d12fdf27b580aacc74318918..c70d40956351ecb14dd036518a8d924f19137929 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.hxx
+++ b/src/SMESH/SMESH_MeshEditor.hxx
@@ -313,9 +313,9 @@ public:
    */
   SMESH_NodeSearcher* GetNodeSearcher();
 
-  int SimplifyFace (const vector<const SMDS_MeshNode *> faceNodes,
-                    vector<const SMDS_MeshNode *>&      poly_nodes,
-                    vector<int>&                        quantities) const;
+  int SimplifyFace (const std::vector<const SMDS_MeshNode *> faceNodes,
+                    std::vector<const SMDS_MeshNode *>&      poly_nodes,
+                    std::vector<int>&                        quantities) const;
   // Split face, defined by <faceNodes>, into several faces by repeating nodes.
   // Is used by MergeNodes()
 
@@ -478,8 +478,8 @@ public:
     * \param nReplaceMap - output map of corresponding nodes
     * \retval Sew_Error  - is a success or not
    */
-  static Sew_Error FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
-                                     set<const SMDS_MeshElement*>& theSide2,
+  static Sew_Error FindMatchingNodes(std::set<const SMDS_MeshElement*>& theSide1,
+                                     std::set<const SMDS_MeshElement*>& theSide2,
                                      const SMDS_MeshNode*          theFirstNode1,
                                      const SMDS_MeshNode*          theFirstNode2,
                                      const SMDS_MeshNode*          theSecondNode1,

diff --git a/src/SMESH/SMESH_MesherHelper.cxx b/src/SMESH/SMESH_MesherHelper.cxx
index 5b74f1ded20bf67d23e99681a8ab8e66731bcfa8..11a00e5e442d9f59bab8604f7eaa114a887f44a2 100644 (file)
--- a/src/SMESH/SMESH_MesherHelper.cxx
+++ b/src/SMESH/SMESH_MesherHelper.cxx
@@ -994,14 +994,14 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
 
   // load nodes from theBaseEdge
 
-  set<const SMDS_MeshNode*> loadedNodes;
+  std::set<const SMDS_MeshNode*> loadedNodes;
   const SMDS_MeshNode* nullNode = 0;
 
-  vector<const SMDS_MeshNode*> & nVecf = theParam2ColumnMap[ 0.];
+  std::vector<const SMDS_MeshNode*> & nVecf = theParam2ColumnMap[ 0.];
   nVecf.resize( vsize, nullNode );
   loadedNodes.insert( nVecf[ 0 ] = smVfb->GetNodes()->next() );
 
-  vector<const SMDS_MeshNode*> & nVecl = theParam2ColumnMap[ 1.];
+  std::vector<const SMDS_MeshNode*> & nVecl = theParam2ColumnMap[ 1.];
   nVecl.resize( vsize, nullNode );
   loadedNodes.insert( nVecl[ 0 ] = smVlb->GetNodes()->next() );
 
@@ -1020,7 +1020,7 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
       return false;
     }
     double u = ( pos->GetUParameter() - f ) / range;
-    vector<const SMDS_MeshNode*> & nVec = theParam2ColumnMap[ u ];
+    std::vector<const SMDS_MeshNode*> & nVec = theParam2ColumnMap[ u ];
     nVec.resize( vsize, nullNode );
     loadedNodes.insert( nVec[ 0 ] = node );
   }
@@ -1030,7 +1030,7 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
 
   // load nodes from e1
 
-  map< double, const SMDS_MeshNode*> sortedNodes; // sort by param on edge
+  std::map< double, const SMDS_MeshNode*> sortedNodes; // sort by param on edge
   nIt = sm1->GetNodes();
   while ( nIt->more() ) {
     node = nIt->next();
@@ -1041,10 +1041,10 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
     if ( !pos ) {
       return false;
     }
-    sortedNodes.insert( make_pair( pos->GetUParameter(), node ));
+    sortedNodes.insert( std::make_pair( pos->GetUParameter(), node ));
   }
   loadedNodes.insert( nVecf[ vsize - 1 ] = smVft->GetNodes()->next() );
-  map< double, const SMDS_MeshNode*>::iterator u_n = sortedNodes.begin();
+  std::map< double, const SMDS_MeshNode*>::iterator u_n = sortedNodes.begin();
   int row  = rev1 ? vsize - 1 : 0;
   int dRow = rev1 ? -1 : +1;
   for ( ; u_n != sortedNodes.end(); u_n++ ) {

diff --git a/src/SMESH/SMESH_MesherHelper.hxx b/src/SMESH/SMESH_MesherHelper.hxx
index 41544a3f48304abe137fba028bdcb420a3cd7abd..7f05b08fc883110febcea4fe97b1583dc18c49b1 100644 (file)
--- a/src/SMESH/SMESH_MesherHelper.hxx
+++ b/src/SMESH/SMESH_MesherHelper.hxx
@@ -36,9 +36,9 @@
 
 #include <map>
 
-typedef pair<const SMDS_MeshNode*, const SMDS_MeshNode*> NLink;
-typedef map<NLink, const SMDS_MeshNode*> NLinkNodeMap;
-typedef map<NLink, const SMDS_MeshNode*>::iterator ItNLinkNode;
+typedef std::pair<const SMDS_MeshNode*, const SMDS_MeshNode*> NLink;
+typedef std::map<NLink, const SMDS_MeshNode*> NLinkNodeMap;
+typedef std::map<NLink, const SMDS_MeshNode*>::iterator ItNLinkNode;
 
 /*!
  * \brief It helps meshers to add elements

diff --git a/src/SMESH/SMESH_OctreeNode.hxx b/src/SMESH/SMESH_OctreeNode.hxx
index 4feb86842c154c8757068b6282ce76d83a36b4db..62cddf68844523f2ae4341455fa9788fa55bf73f 100644 (file)
--- a/src/SMESH/SMESH_OctreeNode.hxx
+++ b/src/SMESH/SMESH_OctreeNode.hxx
@@ -49,7 +49,7 @@ class SMESH_OctreeNode : public SMESH_Octree{
 public:
 
   // Constructor
-  SMESH_OctreeNode (const set<const SMDS_MeshNode*>& theNodes, const int maxLevel = -1,
+  SMESH_OctreeNode (const std::set<const SMDS_MeshNode*>& theNodes, const int maxLevel = -1,
                     const int maxNbNodes = 5 , const double minBoxSize = 0.);
 
 //=============================
@@ -66,19 +66,19 @@ public:
   virtual const bool isInside(const SMDS_MeshNode * Node, const double precision = 0. );
 
   // Return in Result a list of Nodes potentials to be near Node
-  void               NodesAround( const SMDS_MeshNode * Node , list<const SMDS_MeshNode*>* Result,
+  void               NodesAround( const SMDS_MeshNode * Node , std::list<const SMDS_MeshNode*>* Result,
                                   const double precision = 0. );
 
   // Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
   // Search for all the nodes in nodes
-  void               FindCoincidentNodes ( set<const SMDS_MeshNode*>* nodes,
+  void               FindCoincidentNodes ( std::set<const SMDS_MeshNode*>* nodes,
                                            const double                theTolerance,
-                                           list< list< const SMDS_MeshNode*> >* theGroupsOfNodes);
+                                           std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes);
 
   // Static method that return in theGroupsOfNodes a list of group of nodes close to each other within
   // theTolerance search for all the nodes in nodes
-  static void        FindCoincidentNodes ( set<const SMDS_MeshNode*> nodes,
-                                           list< list< const SMDS_MeshNode*> >* theGroupsOfNodes,
+  static void        FindCoincidentNodes ( std::set<const SMDS_MeshNode*> nodes,
+                                           std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes,
                                            const double theTolerance = 0.00001, const int maxLevel = -1,
                                            const int maxNbNodes = 5);
   /*!
@@ -114,15 +114,15 @@ protected:
 
   // Return in result a list of nodes closed to Node and remove it from SetOfNodes
   void                  FindCoincidentNodes( const SMDS_MeshNode * Node,
-                                             set<const SMDS_MeshNode*>* SetOfNodes,
-                                             list<const SMDS_MeshNode*>* Result,
+                                             std::set<const SMDS_MeshNode*>* SetOfNodes,
+                                             std::list<const SMDS_MeshNode*>* Result,
                                              const double precision);
 
   // The max number of nodes a leaf box can contain
   int                         myMaxNbNodes;
 
   // The set of nodes inside the box of the Octree (Empty if Octree is not a leaf)
-  set<const SMDS_MeshNode*>   myNodes;
+  std::set<const SMDS_MeshNode*>   myNodes;
 
   // The number of nodes I have inside the box
   int                         myNbNodes;

diff --git a/src/SMESH/SMESH_Pattern.hxx b/src/SMESH/SMESH_Pattern.hxx
index df1ccd0eb38e130aab7e0b004e0e5aff12400b3c..2746f15cc0c74c085b6a38b6a6c1767aa1236cd5 100644 (file)
--- a/src/SMESH/SMESH_Pattern.hxx
+++ b/src/SMESH/SMESH_Pattern.hxx
@@ -246,51 +246,51 @@ private:
   bool setShapeToMesh(const TopoDS_Shape& theShape);
   // Set a shape to be meshed. Return True if meshing is possible
 
-  list< TPoint* > & getShapePoints(const TopoDS_Shape& theShape);
+  std::list< TPoint* > & getShapePoints(const TopoDS_Shape& theShape);
   // Return list of points located on theShape.
   // A list of edge-points include vertex-points (for 2D pattern only).
   // A list of face-points doesnt include edge-points.
   // A list of volume-points doesnt include face-points.
 
-  list< TPoint* > & getShapePoints(const int theShapeID);
+  std::list< TPoint* > & getShapePoints(const int theShapeID);
   // Return list of points located on the shape
 
   bool findBoundaryPoints();
   // If loaded from file, find points to map on edges and faces and
   // compute their parameters
 
-  void arrangeBoundaries (list< list< TPoint* > >& boundaryPoints);
+  void arrangeBoundaries (std::list< std::list< TPoint* > >& boundaryPoints);
   // if there are several wires, arrange boundaryPoints so that
   // the outer wire goes first and fix inner wires orientation;
   // update myKeyPointIDs to correspond to the order of key-points
   // in boundaries; sort internal boundaries by the nb of key-points
 
-  void computeUVOnEdge( const TopoDS_Edge& theEdge, const list< TPoint* > & ePoints );
+  void computeUVOnEdge( const TopoDS_Edge& theEdge, const std::list< TPoint* > & ePoints );
   // compute coordinates of points on theEdge
 
-  bool compUVByIsoIntersection (const list< list< TPoint* > >& boundaryPoints,
+  bool compUVByIsoIntersection (const std::list< std::list< TPoint* > >& boundaryPoints,
                                 const gp_XY&                   theInitUV,
                                 gp_XY&                         theUV,
                                 bool &                         theIsDeformed);
   // compute UV by intersection of iso-lines found by points on edges
 
-  bool compUVByElasticIsolines(const list< list< TPoint* > >& boundaryPoints,
-                               const list< TPoint* >&         pointsToCompute);
+  bool compUVByElasticIsolines(const std::list< std::list< TPoint* > >& boundaryPoints,
+                               const std::list< TPoint* >&         pointsToCompute);
   // compute UV as nodes of iso-poly-lines consisting of
   // segments keeping relative size as in the pattern
 
-  double setFirstEdge (list< TopoDS_Edge > & theWire, int theFirstEdgeID);
+  double setFirstEdge (std::list< TopoDS_Edge > & theWire, int theFirstEdgeID);
   // choose the best first edge of theWire; return the summary distance
   // between point UV computed by isolines intersection and
   // eventual UV got from edge p-curves
 
-  typedef list< list< TopoDS_Edge > > TListOfEdgesList;
+  typedef std::list< std::list< TopoDS_Edge > > TListOfEdgesList;
 
   bool sortSameSizeWires (TListOfEdgesList &                theWireList,
                           const TListOfEdgesList::iterator& theFromWire,
                           const TListOfEdgesList::iterator& theToWire,
                           const int                         theFirstEdgeID,
-                          list< list< TPoint* > >&          theEdgesPointsList );
+                          std::list< std::list< TPoint* > >&          theEdgesPointsList );
   // sort wires in theWireList from theFromWire until theToWire,
   // the wires are set in the order to correspond to the order
   // of boundaries; after sorting, edges in the wires are put
@@ -352,7 +352,7 @@ private:
   // all functions assure that shapes are indexed so that first go
   // ordered vertices, then ordered edge, then faces and maybe a shell
   TopTools_IndexedMapOfOrientedShape   myShapeIDMap;
-  std::map< int, list< TPoint* > >     myShapeIDToPointsMap;
+  std::map< int, std::list< TPoint* > >     myShapeIDToPointsMap;
 
   // for the 2d case:
   // nb of key-points in each of pattern boundaries

diff --git a/src/SMESH/SMESH_subMesh.hxx b/src/SMESH/SMESH_subMesh.hxx
index 9770d6da0a0c7200e52febbb24516c8ea804b612..a825673910a38bcbf467ee25fa2f675bee32c6e2 100644 (file)
--- a/src/SMESH/SMESH_subMesh.hxx
+++ b/src/SMESH/SMESH_subMesh.hxx
@@ -75,7 +75,7 @@ class SMESH_EXPORT SMESH_subMesh
 
   SMESH_subMesh *GetFirstToCompute();
 
-  const map < int, SMESH_subMesh * >& DependsOn();
+  const std::map < int, SMESH_subMesh * >& DependsOn();
   //const map < int, SMESH_subMesh * >&Dependants();
   /*!
    * \brief Return iterator on the submeshes this one depends on
@@ -274,7 +274,7 @@ protected:
   SMESH_Mesh *          _father;
   int                   _Id;
 
-  map < int, SMESH_subMesh * >_mapDepend;
+  std::map < int, SMESH_subMesh * >_mapDepend;
   bool                  _dependenceAnalysed;
 
   int                   _algoState;