ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-28 02:10:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

Win32 Porting.

Browse Source 
Correction of Export/Import defines for Win32 platform.
Removed "using namespace std" from header files.
This commit is contained in:
abd 2008-10-03 11:40:07 +00:00
parent 82061e3a33
commit 3ef56c2b32
44 changed files with 192 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Controls/SMESH_Controls.cxx
View File

@ -51,6 +51,8 @@
#include "SMDS_QuadraticFaceOfNodes.hxx" #include "SMDS_QuadraticFaceOfNodes.hxx"
#include "SMDS_QuadraticEdge.hxx" #include "SMDS_QuadraticEdge.hxx"
using namespace std;
/* /*
AUXILIARY METHODS AUXILIARY METHODS

1
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -49,6 +49,7 @@ static int MYDEBUG = 0;
#define _EDF_NODE_IDS_ #define _EDF_NODE_IDS_
using namespace MED; using namespace MED;
using namespace std;
void void
DriverMED_R_SMESHDS_Mesh DriverMED_R_SMESHDS_Mesh

4
src/DriverUNV/UNV_Utilities.hxx
View File

@ -30,15 +30,13 @@
#include <cassert> #include <cassert>
namespace UNV{ namespace UNV{
using namespace std;
class MESHDRIVERUNV_EXPORT PrefixPrinter{ class MESHDRIVERUNV_EXPORT PrefixPrinter{
static int myCounter; static int myCounter;
public: public:
PrefixPrinter(); PrefixPrinter();
~PrefixPrinter(); ~PrefixPrinter();
static string GetPrefix(); static std::string GetPrefix();
}; };
/** /**

6
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -2,8 +2,6 @@
// Created : Mon Sep 24 18:32:41 2007 // Created : Mon Sep 24 18:32:41 2007
// Author : Edward AGAPOV (eap) // Author : Edward AGAPOV (eap)
using namespace std;
#ifndef SMDS_MeshInfo_HeaderFile #ifndef SMDS_MeshInfo_HeaderFile
#define SMDS_MeshInfo_HeaderFile #define SMDS_MeshInfo_HeaderFile
@ -57,8 +55,8 @@ private:
int myNbPrisms , myNbQuadPrisms ; int myNbPrisms , myNbQuadPrisms ;
int myNbPolyhedrons; int myNbPolyhedrons;
vector<int*> myNb; // pointers to myNb... fields std::vector<int*> myNb; // pointers to myNb... fields
vector<int> myShift; // shift to get an index in myNb by elem->NbNodes() std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes()
}; };
inline SMDS_MeshInfo::SMDS_MeshInfo(): inline SMDS_MeshInfo::SMDS_MeshInfo():

1
src/SMESH/SMESH_2D_Algo.cxx
View File

@ -26,7 +26,6 @@
// Module : SMESH // Module : SMESH
// $Header$ // $Header$
using namespace std;
#include "SMESH_2D_Algo.hxx" #include "SMESH_2D_Algo.hxx"
#include "SMESH_Gen.hxx" #include "SMESH_Gen.hxx"

2
src/SMESH/SMESH_Algo.hxx
View File

@ -150,7 +150,7 @@ public:
* have a name (type) listed in the algorithm. Hypothesis associated to * have a name (type) listed in the algorithm. Hypothesis associated to
* father shape -are not- taken into account (see GetUsedHypothesis) * father shape -are not- taken into account (see GetUsedHypothesis)
*/ */
const list <const SMESHDS_Hypothesis *> & const std::list <const SMESHDS_Hypothesis *> &
GetAppliedHypothesis(SMESH_Mesh & aMesh, GetAppliedHypothesis(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
const bool ignoreAuxiliary=true); const bool ignoreAuxiliary=true);

10
src/SMESH/SMESH_Block.hxx
View File

@ -115,10 +115,10 @@ class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
// ShapeIndex( ID_Ex00 ) == 0 // ShapeIndex( ID_Ex00 ) == 0
// ShapeIndex( ID_Ex10 ) == 1 // 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 // 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 // return vertex IDs of an edge
static int GetCoordIndOnEdge (const int theEdgeID) static int GetCoordIndOnEdge (const int theEdgeID)
@ -161,7 +161,7 @@ class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
bool LoadMeshBlock(const SMDS_MeshVolume* theVolume, bool LoadMeshBlock(const SMDS_MeshVolume* theVolume,
const int theNode000Index, const int theNode000Index,
const int theNode001Index, const int theNode001Index,
vector<const SMDS_MeshNode*>& theOrderedNodes); std::vector<const SMDS_MeshNode*>& theOrderedNodes);
// prepare to work with theVolume and // prepare to work with theVolume and
// return nodes in theVolume corners in the order of TShapeID enum // return nodes in theVolume corners in the order of TShapeID enum
@ -225,7 +225,7 @@ public:
// return coordinates of a point in shell // return coordinates of a point in shell
static bool ShellPoint(const gp_XYZ& theParams, static bool ShellPoint(const gp_XYZ& theParams,
const vector<gp_XYZ>& thePointOnShape, const std::vector<gp_XYZ>& thePointOnShape,
gp_XYZ& thePoint ); gp_XYZ& thePoint );
// computes coordinates of a point in shell by points on sub-shapes // computes coordinates of a point in shell by points on sub-shapes
// and point parameters. // and point parameters.
@ -377,7 +377,7 @@ public:
gp_XYZ myParam; // the best parameters guess gp_XYZ myParam; // the best parameters guess
double myValues[ 4 ]; // values computed at myParam: square distance and 3 derivatives 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 TxyzPair my3x3x3GridNodes[ 27 ]; // to compute the first param guess
bool myGridComputed; bool myGridComputed;
}; };

16
src/SMESH/SMESH_Comment.hxx
View File

@ -33,34 +33,32 @@
# include <string> # include <string>
# include <sstream> # 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() );
} }
template <class T> template <class T>
SMESH_Comment( const T &anything ) { SMESH_Comment( const T &anything ) {
_s << anything ; _s << anything ;
this->string::operator=( _s.str() ); this->std::string::operator=( _s.str() );
} }
template <class T> template <class T>
SMESH_Comment & operator<<( const T &anything ) { SMESH_Comment & operator<<( const T &anything ) {
_s << anything ; _s << anything ;
this->string::operator=( _s.str() ); this->std::string::operator=( _s.str() );
return *this ; return *this ;
} }
}; };

2
src/SMESH/SMESH_Mesh.cxx
View File

@ -69,6 +69,8 @@ static int MYDEBUG = 0;
static int MYDEBUG = 0; static int MYDEBUG = 0;
#endif #endif
using namespace std;
#define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h) #define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
typedef SMESH_HypoFilter THypType; typedef SMESH_HypoFilter THypType;

10
src/SMESH/SMESH_MeshEditor.hxx
View File

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

23
src/SMESH/SMESH_OctreeNode.hxx
View File

@ -24,11 +24,9 @@
// //
// File : SMESH_OctreeNode.hxx // File : SMESH_OctreeNode.hxx
// Created : Tue Jan 16 16:00:00 2007 // Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurélien Motteux (OCC) // Author : Nicolas Geimer & Aurélien Motteux (OCC)
// Module : SMESH // Module : SMESH
using namespace std;
#ifndef _SMESH_OCTREENODE_HXX_ #ifndef _SMESH_OCTREENODE_HXX_
#define _SMESH_OCTREENODE_HXX_ #define _SMESH_OCTREENODE_HXX_
@ -51,7 +49,7 @@ class SMESH_OctreeNode : public SMESH_Octree{
public: public:
// Constructor // 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.); 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. ); virtual const bool isInside(const SMDS_MeshNode * Node, const double precision = 0. );
// Return in Result a list of Nodes potentials to be near Node // 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. ); const double precision = 0. );
// Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance // Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
// Search for all the nodes in nodes // 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, 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 // 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 // theTolerance search for all the nodes in nodes
static void FindCoincidentNodes ( set<const SMDS_MeshNode*> nodes, static void FindCoincidentNodes ( std::set<const SMDS_MeshNode*> nodes,
list< list< const SMDS_MeshNode*> >* theGroupsOfNodes, std::list< std::list< const SMDS_MeshNode*> >* theGroupsOfNodes,
const double theTolerance = 0.00001, const int maxLevel = -1, const double theTolerance = 0.00001, const int maxLevel = -1,
const int maxNbNodes = 5); const int maxNbNodes = 5);
/*! /*!
@ -116,15 +115,15 @@ protected:
// Return in result a list of nodes closed to Node and remove it from SetOfNodes // Return in result a list of nodes closed to Node and remove it from SetOfNodes
void FindCoincidentNodes( const SMDS_MeshNode * Node, void FindCoincidentNodes( const SMDS_MeshNode * Node,
set<const SMDS_MeshNode*>* SetOfNodes, std::set<const SMDS_MeshNode*>* SetOfNodes,
list<const SMDS_MeshNode*>* Result, std::list<const SMDS_MeshNode*>* Result,
const double precision); const double precision);
// The max number of nodes a leaf box can contain // The max number of nodes a leaf box can contain
int myMaxNbNodes; int myMaxNbNodes;
// The set of nodes inside the box of the Octree (Empty if Octree is not a leaf) // 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 // The number of nodes I have inside the box
int myNbNodes; int myNbNodes;

24
src/SMESH/SMESH_Pattern.hxx
View File

@ -21,8 +21,6 @@
// Created : Mon Aug 2 10:30:00 2004 // Created : Mon Aug 2 10:30:00 2004
// Author : Edward AGAPOV (eap) // Author : Edward AGAPOV (eap)
using namespace std;
#ifndef SMESH_Pattern_HeaderFile #ifndef SMESH_Pattern_HeaderFile
#define SMESH_Pattern_HeaderFile #define SMESH_Pattern_HeaderFile
@ -248,51 +246,51 @@ private:
bool setShapeToMesh(const TopoDS_Shape& theShape); bool setShapeToMesh(const TopoDS_Shape& theShape);
// Set a shape to be meshed. Return True if meshing is possible // 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. // Return list of points located on theShape.
// A list of edge-points include vertex-points (for 2D pattern only). // A list of edge-points include vertex-points (for 2D pattern only).
// A list of face-points doesnt include edge-points. // A list of face-points doesnt include edge-points.
// A list of volume-points doesnt include face-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 // Return list of points located on the shape
bool findBoundaryPoints(); bool findBoundaryPoints();
// If loaded from file, find points to map on edges and faces and // If loaded from file, find points to map on edges and faces and
// compute their parameters // 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 // if there are several wires, arrange boundaryPoints so that
// the outer wire goes first and fix inner wires orientation; // the outer wire goes first and fix inner wires orientation;
// update myKeyPointIDs to correspond to the order of key-points // update myKeyPointIDs to correspond to the order of key-points
// in boundaries; sort internal boundaries by the nb 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 // 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, const gp_XY& theInitUV,
gp_XY& theUV, gp_XY& theUV,
bool & theIsDeformed); bool & theIsDeformed);
// compute UV by intersection of iso-lines found by points on edges // compute UV by intersection of iso-lines found by points on edges
bool compUVByElasticIsolines(const list< list< TPoint* > >& boundaryPoints, bool compUVByElasticIsolines(const std::list< std::list< TPoint* > >& boundaryPoints,
const list< TPoint* >& pointsToCompute); const std::list< TPoint* >& pointsToCompute);
// compute UV as nodes of iso-poly-lines consisting of // compute UV as nodes of iso-poly-lines consisting of
// segments keeping relative size as in the pattern // 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 // choose the best first edge of theWire; return the summary distance
// between point UV computed by isolines intersection and // between point UV computed by isolines intersection and
// eventual UV got from edge p-curves // 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, bool sortSameSizeWires (TListOfEdgesList & theWireList,
const TListOfEdgesList::iterator& theFromWire, const TListOfEdgesList::iterator& theFromWire,
const TListOfEdgesList::iterator& theToWire, const TListOfEdgesList::iterator& theToWire,
const int theFirstEdgeID, const int theFirstEdgeID,
list< list< TPoint* > >& theEdgesPointsList ); std::list< std::list< TPoint* > >& theEdgesPointsList );
// sort wires in theWireList from theFromWire until theToWire, // sort wires in theWireList from theFromWire until theToWire,
// the wires are set in the order to correspond to the order // the wires are set in the order to correspond to the order
// of boundaries; after sorting, edges in the wires are put // 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 // all functions assure that shapes are indexed so that first go
// ordered vertices, then ordered edge, then faces and maybe a shell // ordered vertices, then ordered edge, then faces and maybe a shell
TopTools_IndexedMapOfOrientedShape myShapeIDMap; TopTools_IndexedMapOfOrientedShape myShapeIDMap;
std::map< int, list< TPoint* > > myShapeIDToPointsMap; std::map< int, std::list< TPoint* > > myShapeIDToPointsMap;
// for the 2d case: // for the 2d case:
// nb of key-points in each of pattern boundaries // nb of key-points in each of pattern boundaries

6
src/SMESHClient/SMESH_Client.cxx
View File

@ -35,7 +35,7 @@
#include CORBA_SERVER_HEADER(SALOME_Component) #include CORBA_SERVER_HEADER(SALOME_Component)
#include CORBA_SERVER_HEADER(SALOME_Exception) #include CORBA_SERVER_HEADER(SALOME_Exception)
#include "OpUtil.hxx" #include "Basics_Utils.hxx"
#include "utilities.h" #include "utilities.h"
#ifdef WNT #ifdef WNT
@ -60,6 +60,8 @@ static int MYDEBUG = 0;
static int MYDEBUG = 0; static int MYDEBUG = 0;
#endif #endif
using namespace std;
namespace namespace
{ {
@ -591,7 +593,7 @@ SMESH_Client::GetSMESHGen(CORBA::ORB_ptr theORB,
Engines::Component_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH"); Engines::Component_var aComponent = aLifeCycleCORBA.FindOrLoad_Component("FactoryServer","SMESH");
aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent); aMeshGen = SMESH::SMESH_Gen::_narrow(aComponent);
std::string aClientHostName = GetHostname(); std::string aClientHostName = Kernel_Utils::GetHostname();
Engines::Container_var aServerContainer = aMeshGen->GetContainerRef(); Engines::Container_var aServerContainer = aMeshGen->GetContainerRef();
CORBA::String_var aServerHostName = aServerContainer->getHostName(); CORBA::String_var aServerHostName = aServerContainer->getHostName();
CORBA::Long aServerPID = aServerContainer->getPID(); CORBA::Long aServerPID = aServerContainer->getPID();

4
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -438,9 +438,9 @@ private:
void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index ) void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
{ {
//Update or build submesh //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() ) 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 it->second->AddNode( aNode ); // add aNode to submesh
} }

2
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

@ -94,6 +94,8 @@
#include <vector> #include <vector>
#include <set> #include <set>
using namespace std;
#define SPACING 5 #define SPACING 5
#define MARGIN 10 #define MARGIN 10

4
src/SMESHGUI/SMESHGUI_EditMeshDlg.h
View File

@ -18,8 +18,6 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
using namespace std;
#ifndef SMESHGUI_EditMeshDlg_H #ifndef SMESHGUI_EditMeshDlg_H
#define SMESHGUI_EditMeshDlg_H #define SMESHGUI_EditMeshDlg_H
@ -80,7 +78,7 @@ class SMESHGUI_EXPORT SMESHGUI_EditMeshDlg : public QDialog
void onEditGroup(); void onEditGroup();
void FindGravityCenter(TColStd_MapOfInteger & ElemsIdMap, 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 // add the centers of gravity of ElemsIdMap elements to the GrCentersXYZ list
private: private:

2
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -74,6 +74,8 @@
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
using namespace std;
//================================================================================ //================================================================================
/*! /*!
* \brief Constructor * \brief Constructor

3
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.cxx
View File

@ -67,10 +67,11 @@
#include <qapplication.h> #include <qapplication.h>
#include <qstringlist.h> #include <qstringlist.h>
using namespace std;
#define SPACING 5 #define SPACING 5
#define MARGIN 10 #define MARGIN 10
enum { EDGE = 0, FACE, VOLUME }; enum { EDGE = 0, FACE, VOLUME };
/*! /*!

2
src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx
View File

@ -67,6 +67,8 @@
#define SPACING 5 #define SPACING 5
#define MARGIN 10 #define MARGIN 10
using namespace std;
/*! /*!
\class BusyLocker \class BusyLocker
\brief Simple 'busy state' flag locker. \brief Simple 'busy state' flag locker.

4
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -17,8 +17,6 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
using namespace std;
#ifndef SMESHGUI_VTKUtils_HeaderFile #ifndef SMESHGUI_VTKUtils_HeaderFile
#define SMESHGUI_VTKUtils_HeaderFile #define SMESHGUI_VTKUtils_HeaderFile
@ -61,7 +59,7 @@ class SALOME_Actor;
namespace SMESH { namespace SMESH {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
typedef pair<int,string> TKeyOfVisualObj; typedef std::pair<int,std::string> TKeyOfVisualObj;
SMESHGUI_EXPORT SMESHGUI_EXPORT
TVisualObjPtr GetVisualObj(int theStudyId, TVisualObjPtr GetVisualObj(int theStudyId,

46
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -31,6 +31,7 @@
#include <TColStd_HSequenceOfInteger.hxx> #include <TColStd_HSequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
#ifdef _DEBUG_ #ifdef _DEBUG_
@ -39,6 +40,8 @@ static int MYDEBUG = 0;
static int MYDEBUG = 0; static int MYDEBUG = 0;
#endif #endif
using namespace std;
static TCollection_AsciiString NotPublishedObjectName() static TCollection_AsciiString NotPublishedObjectName()
{ {
return "__NOT__Published__Object__"; return "__NOT__Published__Object__";
@ -61,10 +64,10 @@ namespace SMESH
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
if(!aStudy->_is_nil()){ if(!aStudy->_is_nil()){
std::string aString = myStream.str(); string aString = myStream.str();
TCollection_AsciiString aCollection(Standard_CString(aString.c_str())); TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection); aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
if(MYDEBUG) MESSAGE(aString); if(MYDEBUG) MESSAGE(aString);
} }
} }
} }
@ -171,11 +174,12 @@ namespace SMESH
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
if(!aSObject->_is_nil()) { if(!aSObject->_is_nil())
myStream << aSObject->GetID(); myStream << aSObject->GetID();
} else if ( !CORBA::is_nil(theArg)) { else if ( !CORBA::is_nil(theArg)) {
if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object if ( aSMESHGen->CanPublishInStudy( theArg )) { // not published SMESH object
myStream << "smeshObj_" << size_t(theArg); myStream << "smeshObj_" << size_t(theArg);
}
else else
myStream << NotPublishedObjectName(); myStream << NotPublishedObjectName();
} }
@ -458,6 +462,34 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
aScript += DumpPython_impl(aStudy->StudyId(), aMap, aMapNames, aScript += DumpPython_impl(aStudy->StudyId(), aMap, aMapNames,
isPublished, isValidScript, aSavedTrace); 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(); int aLen = aScript.Length();
unsigned char* aBuffer = new unsigned char[aLen+1]; unsigned char* aBuffer = new unsigned char[aLen+1];
strcpy((char*)aBuffer, aScript.ToCString()); strcpy((char*)aBuffer, aScript.ToCString());

26
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -72,16 +72,16 @@ public:
mapIdToId.clear(); mapIdToId.clear();
} }
// register object in the internal map and return its id // register object in the internal map and return its id
int addObject( string theIOR ) int addObject( std::string theIOR )
{ {
int nextId = getNextId(); int nextId = getNextId();
mapIdToIOR[ nextId ] = theIOR; mapIdToIOR[ nextId ] = theIOR;
return nextId; return nextId;
} }
// find the object id in the internal map by the IOR // 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 ) { for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {
if ( imap->second == theIOR ) if ( imap->second == theIOR )
return imap->first; return imap->first;
@ -89,18 +89,18 @@ public:
return 0; return 0;
} }
// get object's IOR by id // get object's IOR by id
string getIORbyId( const int theId ) std::string getIORbyId( const int theId )
{ {
if ( mapIdToIOR.find( theId ) != mapIdToIOR.end() ) if ( mapIdToIOR.find( theId ) != mapIdToIOR.end() )
return mapIdToIOR[ theId ]; 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() ) if ( mapIdToId.find( theOldId ) != mapIdToId.end() )
return getIORbyId( mapIdToId[ theOldId ] ); return getIORbyId( mapIdToId[ theOldId ] );
return string( "" ); return std::string( "" );
} }
// maps old object id to the new one (used when restoring data) // maps old object id to the new one (used when restoring data)
void mapOldToNew( const int oldId, const int newId ) { void mapOldToNew( const int oldId, const int newId ) {
@ -108,7 +108,7 @@ public:
} }
// get old id by a new one // get old id by a new one
int getOldId( const int newId ) { int getOldId( const int newId ) {
map<int, int>::iterator imap; std::map<int, int>::iterator imap;
for ( imap = mapIdToId.begin(); imap != mapIdToId.end(); ++imap ) { for ( imap = mapIdToId.begin(); imap != mapIdToId.end(); ++imap ) {
if ( imap->second == newId ) if ( imap->second == newId )
return imap->first; return imap->first;
@ -126,8 +126,8 @@ private:
return id; return id;
} }
map<int, string> mapIdToIOR; // persistent-to-transient map std::map<int, std::string> mapIdToIOR; // persistent-to-transient map
map<int, int> mapIdToId; // used to translate object from persistent to transient form 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 ) typename TInterface::_var_type GetObjectByOldId( const int oldID )
{ {
if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) { if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {
string ior = myStudyContext->getIORbyOldId( oldID ); std::string ior = myStudyContext->getIORbyOldId( oldID );
if ( !ior.empty() ) if ( !ior.empty() )
return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() )); return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
} }
@ -492,9 +492,9 @@ private:
::SMESH_Gen myGen; // SMESH_Gen local implementation ::SMESH_Gen myGen; // SMESH_Gen local implementation
// hypotheses managing // 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 GEOM_Client* myShapeReader; // Shape reader
SALOMEDS::Study_var myCurrentStudy; // Current study SALOMEDS::Study_var myCurrentStudy; // Current study

2
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -47,6 +47,8 @@ static int MYDEBUG = 0;
static int MYDEBUG = 0; static int MYDEBUG = 0;
#endif #endif
using namespace std;
//============================================================================= //=============================================================================
/*! /*!
* Get...Tag [ static ] * Get...Tag [ static ]

6
src/SMESH_I/SMESH_MEDFamily_i.hxx
View File

@ -48,16 +48,16 @@ protected :
int _numberOfAttribute; int _numberOfAttribute;
int * _attributeIdentifier; int * _attributeIdentifier;
int * _attributeValue; int * _attributeValue;
string * _attributeDescription; std::string * _attributeDescription;
int _numberOfGroup ; int _numberOfGroup ;
string * _groupName ; std::string * _groupName ;
public : public :
// Constructors and associated internal methods // Constructors and associated internal methods
SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm, 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); SMESH_MEDFamily_i(const SMESH_MEDFamily_i & f);
// IDL Methods // IDL Methods

12
src/SMESH_I/SMESH_MEDMesh_i.hxx
View File

@ -55,22 +55,22 @@ protected:
::SMESH_Mesh_i * _mesh_i; ::SMESH_Mesh_i * _mesh_i;
SMESHDS_Mesh *_meshDS; SMESHDS_Mesh *_meshDS;
string _meshId; std::string _meshId;
bool _compte; bool _compte;
bool _creeFamily; bool _creeFamily;
int _indexElts; int _indexElts;
int _indexEnts; int _indexEnts;
int _famIdent; 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]; SALOME_MED::long_array_var _seq_elemId[MED_NBR_GEOMETRIE_MAILLE];
map < SALOME_MED::medEntityMesh, int >_mapNbTypes; std::map < SALOME_MED::medEntityMesh, int >_mapNbTypes;
map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes; std::map < SALOME_MED::medEntityMesh, int >_mapIndToVectTypes;
vector < SALOME_MED::medGeometryElement > std::vector < SALOME_MED::medGeometryElement >
_TypesId[MED_NBR_GEOMETRIE_MAILLE]; _TypesId[MED_NBR_GEOMETRIE_MAILLE];
vector < SALOME_MED::FAMILY_ptr > _families; std::vector < SALOME_MED::FAMILY_ptr > _families;
public: public:
// Constructors and associated internal methods // Constructors and associated internal methods

8
src/SMESH_I/SMESH_MEDSupport_i.hxx
View File

@ -31,7 +31,6 @@
#include <SALOMEconfig.h> #include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(MED) #include CORBA_SERVER_HEADER(MED)
#include <string>
#include "SMESHDS_Mesh.hxx" #include "SMESHDS_Mesh.hxx"
#include "SMESHDS_SubMesh.hxx" #include "SMESHDS_SubMesh.hxx"
@ -40,6 +39,7 @@
#include "SMESH_MEDSupport_i.hxx" #include "SMESH_MEDSupport_i.hxx"
#include "SALOME_GenericObj_i.hh" #include "SALOME_GenericObj_i.hh"
#include <string>
class SMESH_subMesh_i; class SMESH_subMesh_i;
class SMESH_I_EXPORT SMESH_MEDSupport_i: class SMESH_I_EXPORT SMESH_MEDSupport_i:
@ -49,7 +49,7 @@ class SMESH_I_EXPORT SMESH_MEDSupport_i:
// Constructors and associated internal methods // Constructors and associated internal methods
SMESH_MEDSupport_i(SMESH_subMesh_i * sm, 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); SMESH_MEDSupport_i(const SMESH_MEDSupport_i & s);
// IDL Methods // IDL Methods
@ -102,8 +102,8 @@ class SMESH_I_EXPORT SMESH_MEDSupport_i:
::SMESH_subMesh_i * _subMesh_i; ::SMESH_subMesh_i * _subMesh_i;
SMESHDS_Mesh * _meshDS; SMESHDS_Mesh * _meshDS;
string _name; std::string _name;
string _description; std::string _description;
bool _isOnAllElements; bool _isOnAllElements;
bool _seqNumber; bool _seqNumber;
int _seqLength; int _seqLength;

12
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -331,7 +331,7 @@ public:
SMESH::SMESH_subMesh_ptr getSubMesh(int shapeID); SMESH::SMESH_subMesh_ptr getSubMesh(int shapeID);
// return an existing subMesh object for the shapeID. shapeID == submeshID. // 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. // return an existing group object.
/*! /*!
@ -446,8 +446,8 @@ public:
*/ */
virtual SALOME_MED::MedFileInfo* GetMEDFileInfo(); virtual SALOME_MED::MedFileInfo* GetMEDFileInfo();
map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI std::map<int, SMESH_subMesh_i*> _mapSubMesh_i; //NRI
map<int, ::SMESH_subMesh*> _mapSubMesh; //NRI std::map<int, ::SMESH_subMesh*> _mapSubMesh; //NRI
private: private:
@ -456,9 +456,9 @@ private:
SMESH_Gen_i* _gen_i; SMESH_Gen_i* _gen_i;
int _id; // id given by creator (unique within the creator instance) int _id; // id given by creator (unique within the creator instance)
int _studyId; int _studyId;
map<int, SMESH::SMESH_subMesh_ptr> _mapSubMeshIor; std::map<int, SMESH::SMESH_subMesh_ptr> _mapSubMeshIor;
map<int, SMESH::SMESH_GroupBase_ptr> _mapGroups; std::map<int, SMESH::SMESH_GroupBase_ptr> _mapGroups;
map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo; std::map<int, SMESH::SMESH_Hypothesis_ptr> _mapHypo;
SALOME_MED::MedFileInfo_var myFileInfo; SALOME_MED::MedFileInfo_var myFileInfo;
}; };

1
src/SMESH_I/SMESH_Pattern_i.cxx
View File

@ -47,6 +47,7 @@
#include <set> #include <set>
using SMESH::TPythonDump; using SMESH::TPythonDump;
using namespace std;
//======================================================================= //=======================================================================
//function : dumpErrorCode //function : dumpErrorCode

2
src/StdMeshers/StdMeshers_Distribution.cxx
View File

@ -41,6 +41,8 @@
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#endif #endif
using namespace std;
Function::Function( const int conv ) Function::Function( const int conv )
: myConv( conv ) : myConv( conv )
{ {

8
src/StdMeshers/StdMeshers_Distribution.hxx
View File

@ -29,8 +29,6 @@
#ifndef _STD_MESHERS_DISTRIBUTION_HXX_ #ifndef _STD_MESHERS_DISTRIBUTION_HXX_
#define _STD_MESHERS_DISTRIBUTION_HXX_ #define _STD_MESHERS_DISTRIBUTION_HXX_
using namespace std;
#include "SMESH_StdMeshers.hxx" #include "SMESH_StdMeshers.hxx"
#include <vector> #include <vector>
@ -107,14 +105,14 @@ STDMESHERS_EXPORT
bool buildDistribution( const Function& f, bool buildDistribution( const Function& f,
const double start, const double end, const double start, const double end,
const int nbSeg, const int nbSeg,
vector<double>& data, std::vector<double>& data,
const double eps ); const double eps );
STDMESHERS_EXPORT STDMESHERS_EXPORT
bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end, 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 STDMESHERS_EXPORT
bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end, 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 #endif

2
src/StdMeshers/StdMeshers_FaceSide.cxx
View File

@ -53,6 +53,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

24
src/StdMeshers/StdMeshers_FaceSide.hxx
View File

@ -90,7 +90,7 @@ public:
* \brief Wrap several edges. Edges must be properly ordered and oriented. * \brief Wrap several edges. Edges must be properly ordered and oriented.
*/ */
StdMeshers_FaceSide(const TopoDS_Face& theFace, StdMeshers_FaceSide(const TopoDS_Face& theFace,
list<TopoDS_Edge>& theEdges, std::list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh, SMESH_Mesh* theMesh,
const bool theIsForward, const bool theIsForward,
const bool theIgnoreMediumNodes); const bool theIgnoreMediumNodes);
@ -130,13 +130,13 @@ public:
* *
* Missing nodes are allowed only on internal vertices * 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 * \brief Simulates detailed data on nodes
* \param isXConst - true if normalized parameter X is constant * \param isXConst - true if normalized parameter X is constant
* \param constValue - constant parameter value * \param constValue - constant parameter value
*/ */
const vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg, const std::vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg,
bool isXConst = 0, bool isXConst = 0,
double constValue = 0) const; double constValue = 0) const;
/*! /*!
@ -194,15 +194,15 @@ public:
protected: protected:
vector<uvPtStruct> myPoints, myFalsePoints; std::vector<uvPtStruct> myPoints, myFalsePoints;
vector<TopoDS_Edge> myEdge; std::vector<TopoDS_Edge> myEdge;
vector<Handle(Geom2d_Curve)> myC2d; std::vector<Handle(Geom2d_Curve)> myC2d;
vector<double> myFirst, myLast; std::vector<double> myFirst, myLast;
vector<double> myNormPar; std::vector<double> myNormPar;
double myLength; double myLength;
int myNbPonits, myNbSegments; int myNbPonits, myNbSegments;
SMESH_Mesh* myMesh; SMESH_Mesh* myMesh;
bool myMissingVertexNodes, myIgnoreMediumNodes; bool myMissingVertexNodes, myIgnoreMediumNodes;
}; };

2
src/StdMeshers/StdMeshers_Hexa_3D.hxx
View File

@ -92,7 +92,7 @@ protected:
int GetFaceIndex(SMESH_Mesh& aMesh, int GetFaceIndex(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape, const TopoDS_Shape& aShape,
const vector<SMESH_subMesh*>& meshFaces, const std::vector<SMESH_subMesh*>& meshFaces,
const TopoDS_Vertex& V0, const TopoDS_Vertex& V0,
const TopoDS_Vertex& V1, const TopoDS_Vertex& V1,
const TopoDS_Vertex& V2, const TopoDS_Vertex& V2,

16
src/StdMeshers/StdMeshers_Penta_3D.hxx
View File

@ -97,7 +97,7 @@ protected:
TopTools_IndexedMapOfOrientedShape myShapeIDMap; TopTools_IndexedMapOfOrientedShape myShapeIDMap;
SMESH_Block myTBlock; SMESH_Block myTBlock;
TopoDS_Shape myEmptyShape; TopoDS_Shape myEmptyShape;
vector<int> myIsEdgeForward; std::vector<int> myIsEdgeForward;
// //
int myErrorStatus; int myErrorStatus;
}; };
@ -214,10 +214,10 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
void MakeNodes(); void MakeNodes();
double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ, double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ,
const int aFaceID, const int aFaceID,
vector<const SMDS_MeshNode*>*& aCol1, std::vector<const SMDS_MeshNode*>*& aCol1,
vector<const SMDS_MeshNode*>*& aCol2); std::vector<const SMDS_MeshNode*>*& aCol2);
void ShapeSupportID(const bool theIsUpperLayer, void ShapeSupportID(const bool theIsUpperLayer,
const SMESH_Block::TShapeID theBNSSID, const SMESH_Block::TShapeID theBNSSID,
@ -256,14 +256,14 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
void * myMesh; void * myMesh;
SMESH_ComputeErrorPtr myErrorStatus; SMESH_ComputeErrorPtr myErrorStatus;
// //
vector <StdMeshers_TNode> myTNodes; std::vector <StdMeshers_TNode> myTNodes;
int myISize; int myISize;
int myJSize; int myJSize;
double myTol3D; // Tolerance value double myTol3D; // Tolerance value
std::map < int, int > myConnectingMap; std::map < int, int > myConnectingMap;
// //
vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face std::vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
vector<gp_XYZ> myShapeXYZ; // point on each sub-shape std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
bool myCreateQuadratic; bool myCreateQuadratic;
SMESH_MesherHelper* myTool; // tool building quadratic elements SMESH_MesherHelper* myTool; // tool building quadratic elements

18
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -242,10 +242,10 @@ private:
BRepAdaptor_Surface mySurface; BRepAdaptor_Surface mySurface;
TopoDS_Edge myBaseEdge; TopoDS_Edge myBaseEdge;
// first and last normalized params and orientaion for each component or it-self // first and last normalized params and orientaion for each component or it-self
vector< pair< double, double> > myParams; std::vector< std::pair< double, double> > myParams;
bool myIsForward; bool myIsForward;
vector< TSideFace* > myComponents; std::vector< TSideFace* > myComponents;
SMESH_MesherHelper * myHelper; SMESH_MesherHelper * myHelper;
public: public:
TSideFace( SMESH_MesherHelper* helper, TSideFace( SMESH_MesherHelper* helper,
const int faceID, const int faceID,
@ -255,7 +255,7 @@ private:
const double first = 0.0, const double first = 0.0,
const double last = 1.0); const double last = 1.0);
TSideFace( const std::vector< TSideFace* >& components, 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( const TSideFace& other );
~TSideFace(); ~TSideFace();
bool IsComplex() const bool IsComplex() const
@ -347,9 +347,9 @@ private:
// container of 4 side faces // container of 4 side faces
TSideFace* mySide; TSideFace* mySide;
// node columns for each base edge // node columns for each base edge
vector< TParam2ColumnMap > myParam2ColumnMaps; std::vector< TParam2ColumnMap > myParam2ColumnMaps;
// to find a column for a node by edge SMESHDS Index // 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; SMESH_ComputeErrorPtr myError;
/*! /*!
@ -395,7 +395,7 @@ public:
* \param nodeColumns - columns of nodes generated from nodes of a mesh face * \param nodeColumns - columns of nodes generated from nodes of a mesh face
* \param helper - helper initialized by mesh and shape to add prisms to * \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); SMESH_MesherHelper* helper);
private: private:
@ -430,7 +430,7 @@ private:
StdMeshers_PrismAsBlock myBlock; StdMeshers_PrismAsBlock myBlock;
SMESH_MesherHelper* myHelper; 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 // map of bottom nodes to the column of nodes above them
// (the column includes the bottom node) // (the column includes the bottom node)

4
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -87,8 +87,8 @@ class StdMeshers_ProjectionUtils
TopoDS_Vertex VV1[2], TopoDS_Vertex VV1[2],
const TopoDS_Face& face2, const TopoDS_Face& face2,
TopoDS_Vertex VV2[2], TopoDS_Vertex VV2[2],
list< TopoDS_Edge > & edges1, std::list< TopoDS_Edge > & edges1,
list< TopoDS_Edge > & edges2); std::list< TopoDS_Edge > & edges2);
/*! /*!
* \brief Insert vertex association defined by a hypothesis into a map * \brief Insert vertex association defined by a hypothesis into a map

2
src/StdMeshers/StdMeshers_Projection_3D.cxx
View File

@ -52,6 +52,8 @@
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <TopoDS.hxx> #include <TopoDS.hxx>
using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; } #define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
#define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z()) #define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z())
#define SHOWYXZ(msg, xyz) // {\ #define SHOWYXZ(msg, xyz) // {\

2
src/StdMeshers/StdMeshers_QuadToTriaAdaptor.cxx
View File

@ -46,6 +46,8 @@
#include <NCollection_Array1.hxx> #include <NCollection_Array1.hxx>
typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger; typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger;
using namespace std;
//======================================================================= //=======================================================================
//function : StdMeshers_QuadToTriaAdaptor //function : StdMeshers_QuadToTriaAdaptor

2
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -46,7 +46,7 @@ enum TSideID { BOTTOM_SIDE=0, RIGHT_SIDE, TOP_SIDE, LEFT_SIDE, NB_SIDES };
typedef uvPtStruct UVPtStruct; typedef uvPtStruct UVPtStruct;
typedef struct faceQuadStruct 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 bool isEdgeOut[4]; // true, if an edge has more nodes, than the opposite
UVPtStruct* uv_grid; UVPtStruct* uv_grid;
~faceQuadStruct(); ~faceQuadStruct();

6
src/StdMeshers/StdMeshers_RadialPrism_3D.hxx
View File

@ -54,8 +54,8 @@ public:
protected: protected:
typedef vector<const SMDS_MeshNode* > TNodeColumn; typedef std::vector<const SMDS_MeshNode* > TNodeColumn;
typedef map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap; typedef std::map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
TNodeColumn* makeNodeColumn( TNode2ColumnMap& n2ColMap, TNodeColumn* makeNodeColumn( TNode2ColumnMap& n2ColMap,
const SMDS_MeshNode* outNode, const SMDS_MeshNode* outNode,
@ -68,7 +68,7 @@ protected:
const StdMeshers_NumberOfLayers* myNbLayerHypo; const StdMeshers_NumberOfLayers* myNbLayerHypo;
const StdMeshers_LayerDistribution* myDistributionHypo; const StdMeshers_LayerDistribution* myDistributionHypo;
SMESH_MesherHelper* myHelper; SMESH_MesherHelper* myHelper;
vector< double > myLayerPositions; std::vector< double > myLayerPositions;
}; };
#endif #endif

2
src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
View File

@ -29,6 +29,8 @@
#include "StdMeshers_SegmentAroundVertex_0D.hxx" #include "StdMeshers_SegmentAroundVertex_0D.hxx"
using namespace std;
//======================================================================= //=======================================================================
//function : StdMeshers_SegmentAroundVertex_0D //function : StdMeshers_SegmentAroundVertex_0D
//purpose : //purpose :

2
src/StdMeshersGUI/StdMeshersGUI_ObjectReferenceParamWdg.cxx
View File

@ -40,6 +40,8 @@
#include "SALOME_ListIO.hxx" #include "SALOME_ListIO.hxx"
#include "SALOMEDSClient_SObject.hxx" #include "SALOMEDSClient_SObject.hxx"
using namespace std;
//================================================================================ //================================================================================
/*! /*!
* \brief Constructor initialized by filter * \brief Constructor initialized by filter

3
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -27,7 +27,6 @@
// Module : SMESH // Module : SMESH
// $Header$ // $Header$
using namespace std;
#include "StdMeshers_NumberOfSegments_i.hxx" #include "StdMeshers_NumberOfSegments_i.hxx"
#include "SMESH_Gen_i.hxx" #include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx" #include "SMESH_Gen.hxx"
@ -38,6 +37,8 @@ using namespace std;
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
using namespace std;
//============================================================================= //=============================================================================
/*! /*!
* StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i * StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i

2
src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
View File

@ -101,7 +101,7 @@ public:
std::string str; std::string str;
if (stream >> str) { if (stream >> str) {
if ( StudyContext* myStudyContext = gen->GetCurrentStudyContext() ) { 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() ) if ( !ior.empty() )
return TInterface::_narrow(gen->GetORB()->string_to_object( ior.c_str() )); return TInterface::_narrow(gen->GetORB()->string_to_object( ior.c_str() ));
} }