]> SALOME platform Git repositories - modules/smesh.git/commitdiff
Salome HOME
Win32 Porting.
authorabd <abd@opencascade.com>
Fri, 3 Oct 2008 11:40:07 +0000 (11:40 +0000)
committerabd <abd@opencascade.com>
Fri, 3 Oct 2008 11:40:07 +0000 (11:40 +0000)
Correction of Export/Import defines for Win32 platform.
Removed "using namespace std" from header files.

44 files changed:
src/Controls/SMESH_Controls.cxx
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
src/DriverUNV/UNV_Utilities.hxx
src/SMDS/SMDS_MeshInfo.hxx
src/SMESH/SMESH_2D_Algo.cxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Block.hxx
src/SMESH/SMESH_Comment.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_MeshEditor.hxx
src/SMESH/SMESH_OctreeNode.hxx
src/SMESH/SMESH_Pattern.hxx
src/SMESHClient/SMESH_Client.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
src/SMESHGUI/SMESHGUI_EditMeshDlg.h
src/SMESHGUI/SMESHGUI_MeshOp.cxx
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.cxx
src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.h
src/SMESH_I/SMESH_DumpPython.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Gen_i_1.cxx
src/SMESH_I/SMESH_MEDFamily_i.hxx
src/SMESH_I/SMESH_MEDMesh_i.hxx
src/SMESH_I/SMESH_MEDSupport_i.hxx
src/SMESH_I/SMESH_Mesh_i.hxx
src/SMESH_I/SMESH_Pattern_i.cxx
src/StdMeshers/StdMeshers_Distribution.cxx
src/StdMeshers/StdMeshers_Distribution.hxx
src/StdMeshers/StdMeshers_FaceSide.cxx
src/StdMeshers/StdMeshers_FaceSide.hxx
src/StdMeshers/StdMeshers_Hexa_3D.hxx
src/StdMeshers/StdMeshers_Penta_3D.hxx
src/StdMeshers/StdMeshers_Prism_3D.hxx
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
src/StdMeshers/StdMeshers_Projection_3D.cxx
src/StdMeshers/StdMeshers_QuadToTriaAdaptor.cxx
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
src/StdMeshers/StdMeshers_RadialPrism_3D.hxx
src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
src/StdMeshersGUI/StdMeshersGUI_ObjectReferenceParamWdg.cxx
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx

index a8f371a4bc1c859aea8fc52bef5cb677340d4365..569981c317668825c2e55976c945108677150003 100644 (file)
@@ -51,6 +51,8 @@
 #include "SMDS_QuadraticFaceOfNodes.hxx"
 #include "SMDS_QuadraticEdge.hxx"
 
+using namespace std;
+
 
 /*
                             AUXILIARY METHODS
index a15dde026305288ba496f66a7658afb3f47d832e..64ce2bbe90ac14b749a368b5749fcdf7bcb18ad0 100644 (file)
@@ -49,6 +49,7 @@ static int MYDEBUG = 0;
 #define _EDF_NODE_IDS_
 
 using namespace MED;
+using namespace std;
 
 void
 DriverMED_R_SMESHDS_Mesh
index cb6135351d78d33a58fb7f0ece58e96c3b47df7f..cb14b08cee3013a84c41860fb38fadb4ae736c2a 100644 (file)
 #include <cassert>
 
 namespace UNV{
-  using namespace std;
-
   class MESHDRIVERUNV_EXPORT PrefixPrinter{
     static int myCounter;
   public:
     PrefixPrinter();
     ~PrefixPrinter();
 
-    static string GetPrefix();
+    static std::string GetPrefix();
   };
 
   /**
index 8dbccac83965f144b2a56a836d24eef3f5dbab3b..614791264e98f070e747d71a08e763ce60557dda 100644 (file)
@@ -2,8 +2,6 @@
 // Created   : Mon Sep 24 18:32:41 2007
 // Author    : Edward AGAPOV (eap)
 
-using namespace std;
-
 #ifndef SMDS_MeshInfo_HeaderFile
 #define SMDS_MeshInfo_HeaderFile
 
@@ -57,8 +55,8 @@ private:
   int myNbPrisms  , myNbQuadPrisms  ;
   int myNbPolyhedrons;
 
-  vector<int*> myNb; // pointers to myNb... fields
-  vector<int>  myShift; // shift to get an index in myNb by elem->NbNodes()
+  std::vector<int*> myNb; // pointers to myNb... fields
+  std::vector<int>  myShift; // shift to get an index in myNb by elem->NbNodes()
 };
 
 inline SMDS_MeshInfo::SMDS_MeshInfo():
index ade8abfb75c971858dbed3a3c8a29fe75e3c6e9c..368471486aa31d50c9fac65e4880e7f389002c77 100644 (file)
@@ -26,7 +26,6 @@
 //  Module : SMESH
 //  $Header$
 
-using namespace std;
 #include "SMESH_2D_Algo.hxx"
 #include "SMESH_Gen.hxx"
 
index d5178308f35b5d940b27353be6d0ea9091e6cb3e..dff9f7a97efec64ef9235f88c850abcda157ca4c 100644 (file)
@@ -150,7 +150,7 @@ public:
    *  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);
index c5bbc1e2f6561a448fec1b44dd433e362c18a609..14d727012554d11fc4ecb99995a7a9208662a1b1 100644 (file)
@@ -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)
@@ -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;
 };
index 9385dab547097e424665565256cc3acc3f1b6814..9e2a18425acae55492706274fdb41f7aaf8d95f8 100644 (file)
 # include <string>
 # include <sstream>
 
-using namespace std;
-
 /*!
  * \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 :
 
-  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() ;
-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );
   }
 
   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 ;
-    this->string::operator=( _s.str() );
+    this->std::string::operator=( _s.str() );
     return *this ;
   }
 };
index 02383cb286a4b622da7e9b9a6ee7d1f727496fd3..4c3c0a6a0b4a760a958746f4af08bc720a0d67c9 100644 (file)
@@ -69,6 +69,8 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
+using namespace std;
+
 #define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
 
 typedef SMESH_HypoFilter THypType;
index fd5facec2e6ad444d12fdf27b580aacc74318918..c70d40956351ecb14dd036518a8d924f19137929 100644 (file)
@@ -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,
index 70133845d7260d8bdcd47ae7f7d3ae763b4573b6..57a258175d59a3b5ca4f43a70304d264c8519b21 100644 (file)
 //
 // File      : SMESH_OctreeNode.hxx
 // Created   : Tue Jan 16 16:00:00 2007
-// Author    : Nicolas Geimer & Aurélien Motteux  (OCC)
+// Author    : Nicolas Geimer & Aurélien Motteux  (OCC)
 // Module    : SMESH
 
-using namespace std;
-
 #ifndef _SMESH_OCTREENODE_HXX_
 #define _SMESH_OCTREENODE_HXX_
 
@@ -51,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.);
 
 //=============================
@@ -68,19 +66,20 @@ 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);
   /*!
@@ -116,15 +115,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;
index 3a327891462554c7ed17f898698c0b24f17b753d..fe40a5152f192239a26c2b81ce3698727c78f0f0 100644 (file)
@@ -21,8 +21,6 @@
 // Created   : Mon Aug  2 10:30:00 2004
 // Author    : Edward AGAPOV (eap)
 
-using namespace std;
-
 #ifndef SMESH_Pattern_HeaderFile
 #define SMESH_Pattern_HeaderFile
 
@@ -248,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
@@ -354,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
index add923749f7b872b2a712cc7cbfd16b0eccc1aa2..bb6e933181dee50b02b5fc2cddc496bd753e4b11 100644 (file)
@@ -35,7 +35,7 @@
 #include CORBA_SERVER_HEADER(SALOME_Component)
 #include CORBA_SERVER_HEADER(SALOME_Exception)
 
-#include "OpUtil.hxx"
+#include "Basics_Utils.hxx"
 #include "utilities.h"
 
 #ifdef WNT
@@ -60,6 +60,8 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
+using namespace std;
+
 namespace
 {
 
@@ -591,7 +593,7 @@ SMESH_Client::GetSMESHGen(CORBA::ORB_ptr theORB,
     Engines::Component_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH");
     aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent);
     
-    std::string aClientHostName = GetHostname();
+    std::string aClientHostName = Kernel_Utils::GetHostname();
     Engines::Container_var aServerContainer = aMeshGen->GetContainerRef();
     CORBA::String_var aServerHostName = aServerContainer->getHostName();
     CORBA::Long aServerPID = aServerContainer->getPID();
index dac69c0204b0eee73a462d9c4124cf198e420640..1cc122d46c248b46d8aabb8ccb1e4d81f9a07238 100644 (file)
@@ -438,9 +438,9 @@ private:
   void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
   {
     //Update or build submesh
-    map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
+    std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
     if ( it == myShapeIndexToSubMesh.end() )
-      it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh() )).first;
+      it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh() )).first;
     it->second->AddNode( aNode ); // add aNode to submesh
     }
   
index c06738ba03bab2f4decb019690f8231e2ab3d2ab..be850034aee777e03de1a8223f2a004fa60ea1e7 100644 (file)
@@ -94,6 +94,8 @@
 #include <vector>
 #include <set>
 
+using namespace std;
+
 
 #define SPACING 5
 #define MARGIN  10
index 5ea81ec3465efece2745ed6ca40636035cb995d8..5a0279d9cbb9cb59a25e603782b8559c26eae9d8 100644 (file)
@@ -18,8 +18,6 @@
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 
-using namespace std;
-
 #ifndef SMESHGUI_EditMeshDlg_H
 #define SMESHGUI_EditMeshDlg_H
 
@@ -80,7 +78,7 @@ class SMESHGUI_EXPORT SMESHGUI_EditMeshDlg : public QDialog
   void onEditGroup();
 
   void FindGravityCenter(TColStd_MapOfInteger & ElemsIdMap, 
-                        list< gp_XYZ > & GrCentersXYZ);
+    std::list< gp_XYZ > & GrCentersXYZ);
   // add the centers of gravity of ElemsIdMap elements to the GrCentersXYZ list
 
  private:
index 9257f2b6d544620bf7941dd3bb7d61b38ebfc1b9..c515890681f32e3b831d58c1ae247069e86bdf0d 100644 (file)
@@ -74,6 +74,8 @@
 #include <TopoDS_Shape.hxx>
 #include <TopExp_Explorer.hxx>
 
+using namespace std;
+
 //================================================================================
 /*!
  * \brief Constructor
index 5a506dab47727862aed8f983fca50f9847a28a7c..41da2477fbcdeb0115a7d46f547255f431901d68 100644 (file)
 #include <qapplication.h>
 #include <qstringlist.h>
 
+using namespace std;
+
 #define SPACING 5
 #define MARGIN  10
 
-
 enum { EDGE = 0, FACE, VOLUME };
 
 /*!
index c86235c5a7e4f77aed569161cd6eebf18a77387b..650dc26e54f10d551337e69c3eede4f34ae0f2e9 100755 (executable)
@@ -67,6 +67,8 @@
 #define SPACING 5
 #define MARGIN  10
 
+using namespace std;
+
 /*!
   \class BusyLocker
   \brief Simple 'busy state' flag locker.
index d13e37de33c67184efbd7fb80a383308b32cf06a..bd65df64826da6fc50d7a530e7cce76d3c38122b 100644 (file)
@@ -17,8 +17,6 @@
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 
-using namespace std;
-
 #ifndef SMESHGUI_VTKUtils_HeaderFile
 #define SMESHGUI_VTKUtils_HeaderFile
 
@@ -61,7 +59,7 @@ class SALOME_Actor;
 namespace SMESH {
 
   //----------------------------------------------------------------------------
-  typedef pair<int,string> TKeyOfVisualObj;
+  typedef std::pair<int,std::string> TKeyOfVisualObj;
   
 SMESHGUI_EXPORT
   TVisualObjPtr GetVisualObj(int theStudyId, 
index 1fee7112e64d408a5faeee03de017237a258f993..a895ea40ae99f1656bd3dac797802bab71b34428 100644 (file)
@@ -31,6 +31,7 @@
 
 #include <TColStd_HSequenceOfInteger.hxx>
 #include <TCollection_AsciiString.hxx>
+#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
 
 
 #ifdef _DEBUG_
@@ -39,6 +40,8 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
+using namespace std;
+
 static TCollection_AsciiString NotPublishedObjectName()
 {
   return "__NOT__Published__Object__";
@@ -61,10 +64,10 @@ namespace SMESH
       SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
       SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
       if(!aStudy->_is_nil()){
-       std::string aString = myStream.str();
-       TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
-       aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
-       if(MYDEBUG) MESSAGE(aString);
+        string aString = myStream.str();
+             TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
+             aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
+             if(MYDEBUG) MESSAGE(aString);
       }
     }
   }
@@ -171,11 +174,12 @@ namespace SMESH
     SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
     SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
     SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
-    if(!aSObject->_is_nil()) {
+    if(!aSObject->_is_nil())
       myStream << aSObject->GetID();
-    else if ( !CORBA::is_nil(theArg)) {
-      if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object
+    else if ( !CORBA::is_nil(theArg)) {
+      if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object
         myStream << "smeshObj_" << size_t(theArg);
+      }
       else
         myStream << NotPublishedObjectName();
     }
@@ -458,6 +462,34 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
   aScript += DumpPython_impl(aStudy->StudyId(), aMap, aMapNames,
                              isPublished, isValidScript, aSavedTrace);
 
+  //inserting export for Object Names
+  TCollection_AsciiString def = "def RebuildData(theStudy):\n";
+  int pos = aScript.Search( def );
+  if ( pos != -1 )
+  {    
+    //insert global definition
+    TCollection_AsciiString glob;
+    for( Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString It(aMap);
+      It.More(); It.Next() )
+    {      
+      TCollection_AsciiString name = It.Value();
+      //check valid name
+      if ( !name.IsEmpty() && name.Search(' ') == -1 && name.Search( ':' ) == -1
+        && !name.IsIntegerValue() && !name.IsEqual("Hypotheses") && !name.IsEqual("Algorithms") )
+      {
+        if ( glob.Length() > 0 )
+          glob += ',';
+        glob += name;
+      }
+    }
+    if ( glob.Length() > 0 )
+    {
+      glob.Prepend( "\tglobal " );
+      glob += '\n';
+    }
+
+    aScript.Insert( pos + def.Length(), glob );
+  }
   int aLen = aScript.Length(); 
   unsigned char* aBuffer = new unsigned char[aLen+1];
   strcpy((char*)aBuffer, aScript.ToCString());
index ae64c11759fe870ace33dfb2d1c40fd15193f67b..4b08eed358a2d1a9bd24857159934f1b2360081d 100644 (file)
@@ -72,16 +72,16 @@ public:
     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 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;
@@ -89,18 +89,18 @@ public:
     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 ];
-    return string( "" );
+    return std::string( "" );
   }
   // 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 ] );
-    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 ) {
@@ -108,7 +108,7 @@ public:
   }
   // 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;
@@ -126,8 +126,8 @@ private:
     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;       // used to translate object from persistent to transient form
 };
 
 // ===========================================================
@@ -454,7 +454,7 @@ public:
   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() ));
     }
@@ -492,9 +492,9 @@ private:
   ::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
index 3d87ad4f6d96938e36e7546dc87b8e9993774811..22be7c461cd8683f43ac68082a4e6b9b5692b4bb 100644 (file)
@@ -47,6 +47,8 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
+using namespace std;
+
 //=============================================================================
 /*!
  *  Get...Tag [ static ]
index 4dd63f3a1f99d0cd599e4a4fa75ff423f7fb80ab..e530c2e74109fc177ab0a89709150a6c14fa673c 100644 (file)
@@ -48,16 +48,16 @@ protected :
   int       _numberOfAttribute;
   int    *  _attributeIdentifier;
   int    *  _attributeValue;
-  string *  _attributeDescription;
+  std::string *  _attributeDescription;
   int       _numberOfGroup ;
-  string *  _groupName ;
+  std::string *  _groupName ;
   
 
 public :
   
   // Constructors and associated internal methods
   SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm,
-                   string name, string description, SALOME_MED::medEntityMesh entity );
+                   std::string name, std::string description, SALOME_MED::medEntityMesh entity );
   SMESH_MEDFamily_i(const SMESH_MEDFamily_i & f);
   
   // IDL Methods
index ef4526cc6127d24bbb6a1ed03654fc7902806203..21d6dbb498323a749e6ded853dcc8f9153077b79 100644 (file)
@@ -55,22 +55,22 @@ protected:
   ::SMESH_Mesh_i * _mesh_i;
   SMESHDS_Mesh *_meshDS;
   
-  string _meshId;
+  std::string _meshId;
   bool _compte;
   bool _creeFamily;
   int _indexElts;
   int _indexEnts;
   int _famIdent;
   
-  map < SALOME_MED::medGeometryElement, int >_mapIndToSeqElts;
+  std::map < SALOME_MED::medGeometryElement, int >_mapIndToSeqElts;
   SALOME_MED::long_array_var _seq_elemId[MED_NBR_GEOMETRIE_MAILLE];
   
-  map < SALOME_MED::medEntityMesh, int >_mapNbTypes;
-  map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes;
-  vector < SALOME_MED::medGeometryElement >
+  std::map < SALOME_MED::medEntityMesh, int >_mapNbTypes;
+  std::map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes;
+  std::vector < SALOME_MED::medGeometryElement >
   _TypesId[MED_NBR_GEOMETRIE_MAILLE];
   
-  vector < SALOME_MED::FAMILY_ptr > _families;
+  std::vector < SALOME_MED::FAMILY_ptr > _families;
 public:
   
   // Constructors and associated internal methods
index 3a1d164e2378cc39f0be170fd7ee595eb018067d..9f78b16cdc27d665df43e5842c091298ac50267b 100644 (file)
@@ -31,7 +31,6 @@
 
 #include <SALOMEconfig.h>
 #include CORBA_SERVER_HEADER(MED)
-#include <string>
 
 #include "SMESHDS_Mesh.hxx"
 #include "SMESHDS_SubMesh.hxx"
@@ -40,6 +39,7 @@
 
 #include "SMESH_MEDSupport_i.hxx"
 #include "SALOME_GenericObj_i.hh"
+#include <string>
 class SMESH_subMesh_i;
 
 class SMESH_I_EXPORT SMESH_MEDSupport_i:
@@ -49,7 +49,7 @@ class SMESH_I_EXPORT SMESH_MEDSupport_i:
 
 // Constructors and associated internal methods
        SMESH_MEDSupport_i(SMESH_subMesh_i * sm,
-               string name, string description, SALOME_MED::medEntityMesh entity);
+    std::string name, std::string description, SALOME_MED::medEntityMesh entity);
        SMESH_MEDSupport_i(const SMESH_MEDSupport_i & s);
 
 // IDL Methods
@@ -102,8 +102,8 @@ class SMESH_I_EXPORT SMESH_MEDSupport_i:
        ::SMESH_subMesh_i * _subMesh_i;
 
        SMESHDS_Mesh * _meshDS;
-       string _name;
-       string _description;
+       std::string _name;
+       std::string _description;
        bool _isOnAllElements;
        bool _seqNumber;
        int _seqLength;
index 242548369526f30d317b76ba3eb6603e078c1557..6d0f5e47fcc297257bddbcb0103fe32a0b4d68ef 100644 (file)
@@ -331,7 +331,7 @@ public:
   SMESH::SMESH_subMesh_ptr getSubMesh(int shapeID);
   // return an existing subMesh object for the shapeID. shapeID == submeshID.
 
-  const map<int, SMESH::SMESH_GroupBase_ptr>& getGroups() { return _mapGroups; }
+  const std::map<int, SMESH::SMESH_GroupBase_ptr>& getGroups() { return _mapGroups; }
   // return an existing group object.
 
   /*!
@@ -446,8 +446,8 @@ public:
    */
   virtual SALOME_MED::MedFileInfo* GetMEDFileInfo();
 
-  map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
-  map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
+  std::map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
+  std::map<int, ::SMESH_subMesh*> _mapSubMesh;   //NRI
 
 private:
 
@@ -456,9 +456,9 @@ private:
   SMESH_Gen_i* _gen_i;
   int _id;          // id given by creator (unique within the creator instance)
   int _studyId;
-  map<int, SMESH::SMESH_subMesh_ptr>    _mapSubMeshIor;
-  map<int, SMESH::SMESH_GroupBase_ptr>  _mapGroups;
-  map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo;
+  std::map<int, SMESH::SMESH_subMesh_ptr>    _mapSubMeshIor;
+  std::map<int, SMESH::SMESH_GroupBase_ptr>  _mapGroups;
+  std::map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo;
   SALOME_MED::MedFileInfo_var myFileInfo;
 };
 
index 4f730b3874abf276c3f99be4bab1cda2f4d6529a..63107a405fe687c7c1160e5ab3e31a2537d4b0bc 100644 (file)
@@ -47,6 +47,7 @@
 #include <set>
 
 using SMESH::TPythonDump;
+using namespace std;
 
 //=======================================================================
 //function : dumpErrorCode
index fce8298f430ac1708e708921c5811f4d104f6d5b..84e99b20cb4d36bc7602a2c0a4d7e6e55ed84252 100644 (file)
@@ -41,6 +41,8 @@
 #include <Standard_ErrorHandler.hxx>
 #endif
 
+using namespace std;
+
 Function::Function( const int conv )
 : myConv( conv )
 {
index 831a94441d60abce6d9b88c5a263061f14454f8a..124e4e8bc44e740d45b884a2f3c7e2bc749dc2a8 100644 (file)
@@ -29,8 +29,6 @@
 #ifndef _STD_MESHERS_DISTRIBUTION_HXX_
 #define _STD_MESHERS_DISTRIBUTION_HXX_
 
-using namespace std;
-
 #include "SMESH_StdMeshers.hxx"
 
 #include <vector>
@@ -107,14 +105,14 @@ STDMESHERS_EXPORT
 bool buildDistribution( const Function& f,
                        const double start, const double end,
                        const int nbSeg,
-                       vector<double>& data,
+                       std::vector<double>& data,
                        const double eps );
 
 STDMESHERS_EXPORT
 bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
-                       const int nbSeg, vector<double>& data, const double eps );
+                       const int nbSeg, std::vector<double>& data, const double eps );
 STDMESHERS_EXPORT
 bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
-                       const int nbSeg, vector<double>& data, const double eps );
+                       const int nbSeg, std::vector<double>& data, const double eps );
 
 #endif
index d0ec9bcb542448cfad70ee96a5a6b0f7fe7927e6..ebab0bea9c3c79fc4b1872c7f387797e095cfcb3 100644 (file)
@@ -53,6 +53,8 @@
 
 #include "utilities.h"
 
+using namespace std;
+
 //================================================================================
 /*!
  * \brief Constructor of a side of one edge
index e34dfe51235aea00329542e008410156a0fe90cb..aa29e80a7b33c0944d082e8fa6897bd1dcab9033 100644 (file)
@@ -90,7 +90,7 @@ public:
    * \brief Wrap several edges. Edges must be properly ordered and oriented.
    */
   StdMeshers_FaceSide(const TopoDS_Face& theFace,
-                      list<TopoDS_Edge>& theEdges,
+                      std::list<TopoDS_Edge>& theEdges,
                       SMESH_Mesh*        theMesh,
                       const bool         theIsForward,
                       const bool         theIgnoreMediumNodes);
@@ -130,13 +130,13 @@ public:
     *
     * Missing nodes are allowed only on internal vertices
    */
-  const vector<UVPtStruct>& GetUVPtStruct(bool isXConst =0, double constValue =0) const;
+  const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst =0, double constValue =0) const;
   /*!
    * \brief Simulates detailed data on nodes
     * \param isXConst - true if normalized parameter X is constant
     * \param constValue - constant parameter value
    */
-  const vector<UVPtStruct>& SimulateUVPtStruct(int    nbSeg,
+  const std::vector<UVPtStruct>& SimulateUVPtStruct(int    nbSeg,
                                                bool   isXConst   = 0,
                                                double constValue = 0) const;
   /*!
@@ -194,15 +194,15 @@ public:
   
 
 protected:
-  vector<uvPtStruct>           myPoints, myFalsePoints;
-  vector<TopoDS_Edge>          myEdge;
-  vector<Handle(Geom2d_Curve)> myC2d;
-  vector<double>               myFirst, myLast;
-  vector<double>               myNormPar;
-  double                       myLength;
-  int                          myNbPonits, myNbSegments;
-  SMESH_Mesh*                  myMesh;
-  bool                         myMissingVertexNodes, myIgnoreMediumNodes;
+  std::vector<uvPtStruct>           myPoints, myFalsePoints;
+  std::vector<TopoDS_Edge>          myEdge;
+  std::vector<Handle(Geom2d_Curve)> myC2d;
+  std::vector<double>               myFirst, myLast;
+  std::vector<double>               myNormPar;
+  double                            myLength;
+  int                               myNbPonits, myNbSegments;
+  SMESH_Mesh*                       myMesh;
+  bool                              myMissingVertexNodes, myIgnoreMediumNodes;
 };
 
 
index 1f1c4042d1964bfd23b6c3cfa00d0a45bb1eb2b2..c05a94ae44a299debc18c48c1744426a38628ffa 100644 (file)
@@ -92,7 +92,7 @@ protected:
 
   int GetFaceIndex(SMESH_Mesh& aMesh,
                   const TopoDS_Shape& aShape,
-                  const vector<SMESH_subMesh*>& meshFaces,
+                  const std::vector<SMESH_subMesh*>& meshFaces,
                   const TopoDS_Vertex& V0,
                   const TopoDS_Vertex& V1,
                   const TopoDS_Vertex& V2,
index 90eab4c7433ab9ceafdd68f69ef14e32ae3f8111..0f69e68a5f21ba69c15f6aba5cf59eec5c62711f 100644 (file)
@@ -97,7 +97,7 @@ protected:
   TopTools_IndexedMapOfOrientedShape myShapeIDMap;
   SMESH_Block                        myTBlock;
   TopoDS_Shape                       myEmptyShape;
-  vector<int>                        myIsEdgeForward;
+  std::vector<int>                   myIsEdgeForward;
   //
   int myErrorStatus;
 };
@@ -214,10 +214,10 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
 
     void MakeNodes();
 
-    double SetHorizEdgeXYZ(const gp_XYZ&                  aBNXYZ,
-                           const int                      aFaceID,
-                           vector<const SMDS_MeshNode*>*& aCol1,
-                           vector<const SMDS_MeshNode*>*& aCol2);
+    double SetHorizEdgeXYZ(const gp_XYZ&                       aBNXYZ,
+                           const int                           aFaceID,
+                           std::vector<const SMDS_MeshNode*>*& aCol1,
+                           std::vector<const SMDS_MeshNode*>*& aCol2);
 
     void ShapeSupportID(const bool theIsUpperLayer,
                        const SMESH_Block::TShapeID theBNSSID,
@@ -256,14 +256,14 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
     void *                    myMesh;
     SMESH_ComputeErrorPtr     myErrorStatus;
     //
-    vector <StdMeshers_TNode> myTNodes;
+    std::vector <StdMeshers_TNode> myTNodes;
     int                       myISize;
     int                       myJSize;
     double                    myTol3D;        // Tolerance value     
     std::map < int, int >     myConnectingMap;
     //
-    vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
-    vector<gp_XYZ>            myShapeXYZ; // point on each sub-shape
+    std::vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
+    std::vector<gp_XYZ>            myShapeXYZ; // point on each sub-shape
 
     bool myCreateQuadratic;
     SMESH_MesherHelper* myTool; // tool building quadratic elements
index d6fab7b38dc0a096c9f94023d7ae39aedebe0577..00a81e3b72f3cfbe490fd79bbc5791087754c489 100644 (file)
@@ -242,10 +242,10 @@ private:
     BRepAdaptor_Surface             mySurface;
     TopoDS_Edge                     myBaseEdge;
     // first and last normalized params and orientaion for each component or it-self
-    vector< pair< double, double> > myParams;
-    bool                            myIsForward;
-    vector< TSideFace* >            myComponents;
-    SMESH_MesherHelper *            myHelper;
+    std::vector< std::pair< double, double> > myParams;
+    bool                                      myIsForward;
+    std::vector< TSideFace* >                 myComponents;
+    SMESH_MesherHelper *                      myHelper;
   public:
     TSideFace( SMESH_MesherHelper* helper,
                const int           faceID,
@@ -255,7 +255,7 @@ private:
                const double        first = 0.0,
                const double        last = 1.0);
     TSideFace( const std::vector< TSideFace* >&             components,
-               const std::vector< pair< double, double> > & params);
+               const std::vector< std::pair< double, double> > & params);
     TSideFace( const TSideFace& other );
     ~TSideFace();
     bool IsComplex() const
@@ -347,9 +347,9 @@ private:
   // container of 4 side faces
   TSideFace*                 mySide; 
   // node columns for each base edge
-  vector< TParam2ColumnMap > myParam2ColumnMaps;
+  std::vector< TParam2ColumnMap > myParam2ColumnMaps;
   // to find a column for a node by edge SMESHDS Index
-  map< int, pair< TParam2ColumnMap*, bool > > myShapeIndex2ColumnMap;
+  std::map< int, std::pair< TParam2ColumnMap*, bool > > myShapeIndex2ColumnMap;
 
   SMESH_ComputeErrorPtr myError;
   /*!
@@ -395,7 +395,7 @@ public:
     * \param nodeColumns - columns of nodes generated from nodes of a mesh face
     * \param helper - helper initialized by mesh and shape to add prisms to
    */
-  static void AddPrisms( vector<const TNodeColumn*> & nodeColumns,
+  static void AddPrisms( std::vector<const TNodeColumn*> & nodeColumns,
                          SMESH_MesherHelper*          helper);
 
 private:
@@ -430,7 +430,7 @@ private:
   StdMeshers_PrismAsBlock myBlock;
   SMESH_MesherHelper*     myHelper;
 
-  vector<gp_XYZ>            myShapeXYZ; // point on each sub-shape
+  std::vector<gp_XYZ>            myShapeXYZ; // point on each sub-shape
 
   // map of bottom nodes to the column of nodes above them
   // (the column includes the bottom node)
index 8d3939c2de3129343739fae5cb3f0d3cb3e9b8f6..3d5111508a1bd772dd92386a8bee13cfed8251ec 100644 (file)
@@ -87,8 +87,8 @@ class StdMeshers_ProjectionUtils
                                  TopoDS_Vertex         VV1[2],
                                  const TopoDS_Face&    face2,
                                  TopoDS_Vertex         VV2[2],
-                                 list< TopoDS_Edge > & edges1,
-                                 list< TopoDS_Edge > & edges2);
+                                 std::list< TopoDS_Edge > & edges1,
+                                 std::list< TopoDS_Edge > & edges2);
 
   /*!
    * \brief Insert vertex association defined by a hypothesis into a map
index af93f888de2313eacc45570822effb1785534564..a1726f684e5c4d121e6c2f4d046fd5b24471beb2 100644 (file)
@@ -52,6 +52,8 @@
 #include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
 
+using namespace std;
+
 #define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
 #define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z())
 #define SHOWYXZ(msg, xyz) // {\
index 3892ddc9be97f7cdc1d523da44766307809d91f4..13bbf2581fd36ef21ee70a85bbcfd6b93bb45097 100644 (file)
@@ -46,6 +46,8 @@
 #include <NCollection_Array1.hxx>
 typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger;
 
+using namespace std;
+
 
 //=======================================================================
 //function : StdMeshers_QuadToTriaAdaptor
index 18ae6aae9024f7e10f3af501b6e089b27b3232c1..246769e2d67bacd2bf2e80c1ce48b6b0e61544ba 100644 (file)
@@ -46,7 +46,7 @@ enum TSideID { BOTTOM_SIDE=0, RIGHT_SIDE, TOP_SIDE, LEFT_SIDE, NB_SIDES };
 typedef uvPtStruct UVPtStruct;
 typedef struct faceQuadStruct
 {
-  vector< StdMeshers_FaceSide*> side;
+  std::vector< StdMeshers_FaceSide*> side;
   bool isEdgeOut[4]; // true, if an edge has more nodes, than the opposite
   UVPtStruct* uv_grid;
   ~faceQuadStruct();
index b7d7968021c9192ec5c7c45902a7a199ffe14f28..19d1664ec5fbf46c47b0521a67b04203c5039193 100644 (file)
@@ -54,8 +54,8 @@ public:
 
 protected:
 
-  typedef vector<const SMDS_MeshNode* >            TNodeColumn;
-  typedef map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
+  typedef std::vector<const SMDS_MeshNode* >            TNodeColumn;
+  typedef std::map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
 
   TNodeColumn* makeNodeColumn( TNode2ColumnMap&     n2ColMap,
                                const SMDS_MeshNode* outNode,
@@ -68,7 +68,7 @@ protected:
   const StdMeshers_NumberOfLayers*    myNbLayerHypo;
   const StdMeshers_LayerDistribution* myDistributionHypo;
   SMESH_MesherHelper*                 myHelper;
-  vector< double >                    myLayerPositions;
+  std::vector< double >               myLayerPositions;
 };
 
 #endif
index c4e809dca9efed5967057393a9c31c0ad0943047..9610615a9303f66202f79cbae20a5dcadb88ae15 100644 (file)
@@ -29,6 +29,8 @@
 
 #include "StdMeshers_SegmentAroundVertex_0D.hxx"
 
+using namespace std;
+
 //=======================================================================
 //function : StdMeshers_SegmentAroundVertex_0D
 //purpose  : 
index 85ec4d6b42b92c64915ffe3f1da72770f89e7b0e..954beab10e7a0ad892f3ae833033c1899388e4da 100644 (file)
@@ -40,6 +40,8 @@
 #include "SALOME_ListIO.hxx"
 #include "SALOMEDSClient_SObject.hxx"
 
+using namespace std;
+
 //================================================================================
 /*!
  * \brief Constructor initialized by filter
index a5390229476285e7fdd480b097273ace420c0417..82d7f9d95c34fbfe9d2d3d38310f1bae26c0d6e3 100644 (file)
@@ -27,7 +27,6 @@
 //  Module : SMESH
 //  $Header$
 
-using namespace std;
 #include "StdMeshers_NumberOfSegments_i.hxx"
 #include "SMESH_Gen_i.hxx"
 #include "SMESH_Gen.hxx"
@@ -38,6 +37,8 @@ using namespace std;
 
 #include <TCollection_AsciiString.hxx>
 
+using namespace std;
+
 //=============================================================================
 /*!
  *  StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i
index 994f39594cf867f6fb420eab33fb05bca0c58c39..b87f3135bc36024a8a3b61f053981c13f8648687 100644 (file)
@@ -101,7 +101,7 @@ public:
       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() ));
         }