Correction of Export/Import defines for Win32 platform.
Removed "using namespace std" from header files.
#include "SMDS_QuadraticFaceOfNodes.hxx"
#include "SMDS_QuadraticEdge.hxx"
+using namespace std;
+
/*
AUXILIARY METHODS
#define _EDF_NODE_IDS_
using namespace MED;
+using namespace std;
void
DriverMED_R_SMESHDS_Mesh
#include <cassert>
namespace UNV{
- using namespace std;
-
class MESHDRIVERUNV_EXPORT PrefixPrinter{
static int myCounter;
public:
PrefixPrinter();
~PrefixPrinter();
- static string GetPrefix();
+ static std::string GetPrefix();
};
/**
// Created : Mon Sep 24 18:32:41 2007
// Author : Edward AGAPOV (eap)
-using namespace std;
-
#ifndef SMDS_MeshInfo_HeaderFile
#define SMDS_MeshInfo_HeaderFile
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():
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_2D_Algo.hxx"
#include "SMESH_Gen.hxx"
* 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);
// 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)
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
// 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.
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;
};
# 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 ;
}
};
static int MYDEBUG = 0;
#endif
+using namespace std;
+
#define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
typedef SMESH_HypoFilter THypType;
*/
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()
* \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,
//
// 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_
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.);
//=============================
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);
/*!
// 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;
// Created : Mon Aug 2 10:30:00 2004
// Author : Edward AGAPOV (eap)
-using namespace std;
-
#ifndef SMESH_Pattern_HeaderFile
#define SMESH_Pattern_HeaderFile
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
// 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
#include CORBA_SERVER_HEADER(SALOME_Component)
#include CORBA_SERVER_HEADER(SALOME_Exception)
-#include "OpUtil.hxx"
+#include "Basics_Utils.hxx"
#include "utilities.h"
#ifdef WNT
static int MYDEBUG = 0;
#endif
+using namespace std;
+
namespace
{
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();
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
}
#include <vector>
#include <set>
+using namespace std;
+
#define SPACING 5
#define MARGIN 10
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-using namespace std;
-
#ifndef SMESHGUI_EditMeshDlg_H
#define SMESHGUI_EditMeshDlg_H
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:
#include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx>
+using namespace std;
+
//================================================================================
/*!
* \brief Constructor
#include <qapplication.h>
#include <qstringlist.h>
+using namespace std;
+
#define SPACING 5
#define MARGIN 10
-
enum { EDGE = 0, FACE, VOLUME };
/*!
#define SPACING 5
#define MARGIN 10
+using namespace std;
+
/*!
\class BusyLocker
\brief Simple 'busy state' flag locker.
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-using namespace std;
-
#ifndef SMESHGUI_VTKUtils_HeaderFile
#define SMESHGUI_VTKUtils_HeaderFile
namespace SMESH {
//----------------------------------------------------------------------------
- typedef pair<int,string> TKeyOfVisualObj;
+ typedef std::pair<int,std::string> TKeyOfVisualObj;
SMESHGUI_EXPORT
TVisualObjPtr GetVisualObj(int theStudyId,
#include <TColStd_HSequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx>
+#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
#ifdef _DEBUG_
static int MYDEBUG = 0;
#endif
+using namespace std;
+
static TCollection_AsciiString NotPublishedObjectName()
{
return "__NOT__Published__Object__";
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);
}
}
}
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();
}
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());
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;
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 ) {
}
// 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;
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
};
// ===========================================================
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() ));
}
::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
static int MYDEBUG = 0;
#endif
+using namespace std;
+
//=============================================================================
/*!
* Get...Tag [ static ]
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
::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
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(MED)
-#include <string>
#include "SMESHDS_Mesh.hxx"
#include "SMESHDS_SubMesh.hxx"
#include "SMESH_MEDSupport_i.hxx"
#include "SALOME_GenericObj_i.hh"
+#include <string>
class SMESH_subMesh_i;
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
::SMESH_subMesh_i * _subMesh_i;
SMESHDS_Mesh * _meshDS;
- string _name;
- string _description;
+ std::string _name;
+ std::string _description;
bool _isOnAllElements;
bool _seqNumber;
int _seqLength;
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.
/*!
*/
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:
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;
};
#include <set>
using SMESH::TPythonDump;
+using namespace std;
//=======================================================================
//function : dumpErrorCode
#include <Standard_ErrorHandler.hxx>
#endif
+using namespace std;
+
Function::Function( const int conv )
: myConv( conv )
{
#ifndef _STD_MESHERS_DISTRIBUTION_HXX_
#define _STD_MESHERS_DISTRIBUTION_HXX_
-using namespace std;
-
#include "SMESH_StdMeshers.hxx"
#include <vector>
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
#include "utilities.h"
+using namespace std;
+
//================================================================================
/*!
* \brief Constructor of a side of one edge
* \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);
*
* 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;
/*!
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;
};
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,
TopTools_IndexedMapOfOrientedShape myShapeIDMap;
SMESH_Block myTBlock;
TopoDS_Shape myEmptyShape;
- vector<int> myIsEdgeForward;
+ std::vector<int> myIsEdgeForward;
//
int myErrorStatus;
};
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,
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
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,
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
// 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;
/*!
* \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:
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)
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
#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) // {\
#include <NCollection_Array1.hxx>
typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger;
+using namespace std;
+
//=======================================================================
//function : StdMeshers_QuadToTriaAdaptor
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();
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,
const StdMeshers_NumberOfLayers* myNbLayerHypo;
const StdMeshers_LayerDistribution* myDistributionHypo;
SMESH_MesherHelper* myHelper;
- vector< double > myLayerPositions;
+ std::vector< double > myLayerPositions;
};
#endif
#include "StdMeshers_SegmentAroundVertex_0D.hxx"
+using namespace std;
+
//=======================================================================
//function : StdMeshers_SegmentAroundVertex_0D
//purpose :
#include "SALOME_ListIO.hxx"
#include "SALOMEDSClient_SObject.hxx"
+using namespace std;
+
//================================================================================
/*!
* \brief Constructor initialized by filter
// Module : SMESH
// $Header$
-using namespace std;
#include "StdMeshers_NumberOfSegments_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
#include <TCollection_AsciiString.hxx>
+using namespace std;
+
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i
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() ));
}
