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

23237: EDF 12367 - SIGSEGV with Remove group

Browse Source 
(SMESH_Gen_i_1.cxx)

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

+ remove "using namespace std" from headers
This commit is contained in:
eap 2016-02-15 15:08:20 +03:00
parent d2ed8e8dab
commit 20248b6e76
38 changed files with 282 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/Controls/SMESH_Controls.cxx
View File

@ -175,7 +175,7 @@ namespace {
n += q2 ^ q3;
}
double len = n.Modulus();
bool zeroLen = ( len <= numeric_limits<double>::min());
bool zeroLen = ( len <= std::numeric_limits<double>::min());
if ( !zeroLen )
n /= len;
@ -312,12 +312,12 @@ double NumericalFunctor::Round( const double & aVal )
*/
//================================================================================
void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const vector<int>& elements,
const double* minmax,
const bool isLogarithmic)
void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const std::vector<int>& elements,
const double* minmax,
const bool isLogarithmic)
{
if ( nbIntervals < 1 ||
!myMesh ||
@ -336,7 +336,7 @@ void NumericalFunctor::GetHistogram(int nbIntervals,
}
else
{
vector<int>::const_iterator id = elements.begin();
std::vector<int>::const_iterator id = elements.begin();
for ( ; id != elements.end(); ++id )
values.insert( GetValue( *id ));
}
@ -2163,7 +2163,7 @@ bool BareBorderVolume::IsSatisfy(long theElementId )
if ( myTool.IsFreeFace( iF ))
{
const SMDS_MeshNode** n = myTool.GetFaceNodes(iF);
vector< const SMDS_MeshNode*> nodes( n, n+myTool.NbFaceNodes(iF));
std::vector< const SMDS_MeshNode*> nodes( n, n+myTool.NbFaceNodes(iF));
if ( !myMesh->FindElement( nodes, SMDSAbs_Face, /*Nomedium=*/false))
return true;
}
@ -2302,15 +2302,15 @@ void CoincidentNodes::SetMesh( const SMDS_Mesh* theMesh )
while ( nIt->more() )
nodesToCheck.insert( nodesToCheck.end(), nIt->next() );
list< list< const SMDS_MeshNode*> > nodeGroups;
std::list< std::list< const SMDS_MeshNode*> > nodeGroups;
SMESH_OctreeNode::FindCoincidentNodes ( nodesToCheck, &nodeGroups, myToler );
myCoincidentIDs.Clear();
list< list< const SMDS_MeshNode*> >::iterator groupIt = nodeGroups.begin();
std::list< std::list< const SMDS_MeshNode*> >::iterator groupIt = nodeGroups.begin();
for ( ; groupIt != nodeGroups.end(); ++groupIt )
{
list< const SMDS_MeshNode*>& coincNodes = *groupIt;
list< const SMDS_MeshNode*>::iterator n = coincNodes.begin();
std::list< const SMDS_MeshNode*>& coincNodes = *groupIt;
std::list< const SMDS_MeshNode*>::iterator n = coincNodes.begin();
for ( ; n != coincNodes.end(); ++n )
myCoincidentIDs.Add( (*n)->GetID() );
}
@ -2342,7 +2342,7 @@ bool CoincidentElements::IsSatisfy( long theElementId )
if ( const SMDS_MeshElement* e = myMesh->FindElement( theElementId ))
{
if ( e->GetType() != GetType() ) return false;
set< const SMDS_MeshNode* > elemNodes( e->begin_nodes(), e->end_nodes() );
std::set< const SMDS_MeshNode* > elemNodes( e->begin_nodes(), e->end_nodes() );
const int nbNodes = e->NbNodes();
SMDS_ElemIteratorPtr invIt = (*elemNodes.begin())->GetInverseElementIterator( GetType() );
while ( invIt->more() )
@ -2589,18 +2589,20 @@ bool FreeFaces::IsSatisfy( long theId )
int nbNode = aFace->NbNodes();
// collect volumes to check that number of volumes with count equal nbNode not less than 2
typedef map< SMDS_MeshElement*, int > TMapOfVolume; // map of volume counters
typedef map< SMDS_MeshElement*, int >::iterator TItrMapOfVolume; // iterator
typedef std::map< SMDS_MeshElement*, int > TMapOfVolume; // map of volume counters
typedef std::map< SMDS_MeshElement*, int >::iterator TItrMapOfVolume; // iterator
TMapOfVolume mapOfVol;
SMDS_ElemIteratorPtr nodeItr = aFace->nodesIterator();
while ( nodeItr->more() ) {
while ( nodeItr->more() )
{
const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(nodeItr->next());
if ( !aNode ) continue;
SMDS_ElemIteratorPtr volItr = aNode->GetInverseElementIterator(SMDSAbs_Volume);
while ( volItr->more() ) {
while ( volItr->more() )
{
SMDS_MeshElement* aVol = (SMDS_MeshElement*)volItr->next();
TItrMapOfVolume itr = mapOfVol.insert(make_pair(aVol, 0)).first;
TItrMapOfVolume itr = mapOfVol.insert( std::make_pair( aVol, 0 )).first;
(*itr).second++;
}
}
@ -2704,8 +2706,8 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
return;
// iterates on groups and find necessary elements ids
const std::set<SMESHDS_GroupBase*>& aGroups = aMesh->GetGroups();
set<SMESHDS_GroupBase*>::const_iterator GrIt = aGroups.begin();
const std::set<SMESHDS_GroupBase*>& aGroups = aMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator GrIt = aGroups.begin();
for (; GrIt != aGroups.end(); GrIt++)
{
SMESHDS_GroupBase* aGrp = (*GrIt);
@ -2932,10 +2934,10 @@ void ConnectedElements::SetPoint( double x, double y, double z )
// find myNodeID by myXYZ if possible
if ( myMeshModifTracer.GetMesh() )
{
auto_ptr<SMESH_ElementSearcher> searcher
SMESHUtils::Deleter<SMESH_ElementSearcher> searcher
( SMESH_MeshAlgos::GetElementSearcher( (SMDS_Mesh&) *myMeshModifTracer.GetMesh() ));
vector< const SMDS_MeshElement* > foundElems;
std::vector< const SMDS_MeshElement* > foundElems;
searcher->FindElementsByPoint( gp_Pnt(x,y,z), SMDSAbs_All, foundElems );
if ( !foundElems.empty() )
@ -2961,7 +2963,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
if ( !node0 )
return false;
list< const SMDS_MeshNode* > nodeQueue( 1, node0 );
std::list< const SMDS_MeshNode* > nodeQueue( 1, node0 );
std::set< int > checkedNodeIDs;
// algo:
// foreach node in nodeQueue:
@ -3050,8 +3052,8 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
const double cosTol = Cos( myToler * M_PI / 180. );
NCollection_Map< SMESH_TLink, SMESH_TLink > checkedLinks;
std::list< pair< const SMDS_MeshElement*, gp_Vec > > faceQueue;
faceQueue.push_back( make_pair( face, myNorm ));
std::list< std::pair< const SMDS_MeshElement*, gp_Vec > > faceQueue;
faceQueue.push_back( std::make_pair( face, myNorm ));
while ( !faceQueue.empty() )
{
face = faceQueue.front().first;
@ -3074,7 +3076,7 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
if (!normOK || isLessAngle( myNorm, norm, cosTol))
{
myCoplanarIDs.Add( f->GetID() );
faceQueue.push_back( make_pair( f, norm ));
faceQueue.push_back( std::make_pair( f, norm ));
}
}
}

8
src/DriverGMF/DriverGMF_Write.cxx
View File

@ -70,9 +70,9 @@ extern "C"
elem->getshapeId() ); \
}}
#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id ) \
elem->getshapeId() ); \
e2id.insert( e2id.end(), make_pair( elem, gmfID )); \
#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id ) \
elem->getshapeId() ); \
e2id.insert( e2id.end(), std::make_pair( elem, gmfID )); \
}}
#define END_EXTRA_VERTICES_WRITE() \
@ -145,7 +145,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
const SMDS_MeshNode* n = nodeIt->next();
n->GetXYZ( xyz );
GmfSetLin( meshID, GmfVertices, xyz[0], xyz[1], xyz[2], n->getshapeId() );
node2IdMap.insert( node2IdMap.end(), make_pair( n, ++iN ));
node2IdMap.insert( node2IdMap.end(), std::make_pair( n, ++iN ));
}
if ( iN != nbNodes )
return addMessage("Wrong nb of nodes returned by nodesIterator", /*fatal=*/true);

10
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -95,7 +95,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
if ( _nbElemsByGeom.empty() || _elemType != type )
{
_elemType = type;
_nbElemsByGeom.resize( 1, make_pair( SMDSEntity_Last, 0 ));
_nbElemsByGeom.resize( 1, std::make_pair( SMDSEntity_Last, 0 ));
// count nb of elems of each geometry
for ( int iG = 0; iG < SMDSEntity_Last; ++iG )
@ -107,7 +107,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
nbElems = mesh->GetMeshInfo().NbElements( geom );
if ( nbElems < 1 ) continue;
_nbElemsByGeom.push_back( make_pair( geom, nbElems + _nbElemsByGeom.back().second ));
_nbElemsByGeom.push_back( std::make_pair( geom, nbElems + _nbElemsByGeom.back().second ));
}
// add nodes of missing 0D elements on VERTEXes
if ( _addODOnVertices && _elemType == SMDSAbs_0DElement )
@ -118,8 +118,8 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
if ( !nodes.empty() )
{
if ( _nbElemsByGeom.size() == 1 )
_nbElemsByGeom.push_back( make_pair( SMDSEntity_0D, 0));
_nbElemsByGeom.push_back( make_pair( SMDSEntity_Node,
_nbElemsByGeom.push_back( std::make_pair( SMDSEntity_0D, 0));
_nbElemsByGeom.push_back( std::make_pair( SMDSEntity_Node,
nodes.size() + _nbElemsByGeom.back().second ));
}
}
@ -314,7 +314,7 @@ Driver_Mesh::Status DriverMED_W_Field::Perform()
SMDSAbs_EntityType smdsType = _nbElemsByGeom[iG].first;
MED::EGeometrieElement medType = (MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );
int nbElems = _nbElemsByGeom[iG].second - _nbElemsByGeom[iG-1].second;
type2nb.insert( make_pair( medType, nbElems ));
type2nb.insert( std::make_pair( medType, nbElems ));
}
MED::EEntiteMaillage entity = ( _elemType == SMDSAbs_Node ? MED::eNOEUD : MED::eMAILLE );

2
src/SMDS/SMDS_Mesh.hxx
View File

@ -747,7 +747,7 @@ public:
void incrementNodesCapacity(int nbNodes);
void incrementCellsCapacity(int nbCells);
void adjustStructure();
void dumpGrid(string ficdump="dumpGrid");
void dumpGrid(std::string ficdump="dumpGrid");
static int chunkSize;
//! low level modification: add, change or remove node or element

1
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -25,7 +25,6 @@
#define SMDS_MeshInfo_HeaderFile
#include <vector>
using namespace std;
#include "SMESH_SMDS.hxx"

4
src/SMDS/SMDS_VtkVolume.cxx
View File

@ -95,7 +95,7 @@ void SMDS_VtkVolume::initPoly(const std::vector<vtkIdType>& nodeIds,
SMDS_UnstructuredGrid* grid = mesh->getGrid();
//double center[3];
//this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), &center[0]);
vector<vtkIdType> ptIds;
std::vector<vtkIdType> ptIds;
vtkIdType nbFaces = nbNodesPerFace.size();
int k = 0;
for (int i = 0; i < nbFaces; i++)
@ -365,7 +365,7 @@ const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int n
*/
std::vector<int> SMDS_VtkVolume::GetQuantities() const
{
vector<int> quantities;
std::vector<int> quantities;
SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
vtkUnstructuredGrid* grid = mesh->getGrid();
vtkIdType aVtkType = grid->GetCellType(this->myVtkID);

2
src/SMESH/SMESH_Algo.hxx
View File

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

8
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -93,11 +93,11 @@ public:
SMESH_EXPORT ElemFeatures& Init( double diameter )
{ myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; }
SMESH_EXPORT ElemFeatures& Init( vector<int>& quanities, bool isQuad=false )
SMESH_EXPORT ElemFeatures& Init( std::vector<int>& quanities, bool isQuad=false )
{ myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
myPolyhedQuantities.swap( quanities ); return *this; }
SMESH_EXPORT ElemFeatures& Init( const vector<int>& quanities, bool isQuad=false )
SMESH_EXPORT ElemFeatures& Init( const std::vector<int>& quanities, bool isQuad=false )
{ myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
myPolyhedQuantities = quanities; return *this; }
@ -777,8 +777,8 @@ public:
const bool theHasRefPoint,
const gp_Pnt& theRefPoint,
const bool theMakeGroups);
void LinearAngleVariation(const int NbSteps,
list<double>& theAngles);
void LinearAngleVariation(const int NbSteps,
std::list<double>& theAngles);
bool doubleNodes( SMESHDS_Mesh* theMeshDS,
const TIDSortedElemSet& theElems,

26
src/SMESH/SMESH_ProxyMesh.cxx
View File

@ -45,7 +45,7 @@ SMESH_ProxyMesh::SMESH_ProxyMesh():_mesh(0)
*/
//================================================================================
SMESH_ProxyMesh::SMESH_ProxyMesh(vector<SMESH_ProxyMesh::Ptr>& components):
SMESH_ProxyMesh::SMESH_ProxyMesh(std::vector<SMESH_ProxyMesh::Ptr>& components):
_mesh(0)
{
if ( components.empty() ) return;
@ -68,8 +68,8 @@ SMESH_ProxyMesh::SMESH_ProxyMesh(vector<SMESH_ProxyMesh::Ptr>& components):
if ( _subMeshes[j] )
{
// unite 2 sub-meshes
set< const SMDS_MeshElement * > elems( _subMeshes[j]->_elements.begin(),
_subMeshes[j]->_elements.end());
std::set< const SMDS_MeshElement * > elems( _subMeshes[j]->_elements.begin(),
_subMeshes[j]->_elements.end());
elems.insert( m->_subMeshes[j]->_elements.begin(),
m->_subMeshes[j]->_elements.end());
_subMeshes[j]->_elements.assign( elems.begin(), elems.end() );
@ -103,7 +103,7 @@ SMESH_ProxyMesh::~SMESH_ProxyMesh()
delete _subMeshes[i];
_subMeshes.clear();
set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.begin();
std::set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.begin();
for ( ; i != _elemsInMesh.end(); ++i )
GetMeshDS()->RemoveFreeElement( *i, 0 );
_elemsInMesh.clear();
@ -203,12 +203,12 @@ namespace
class TFilteringIterator : public SMDS_ElemIterator
{
SMDS_ElemIteratorPtr _iter;
const SMDS_MeshElement * _curElem;
vector< SMDSAbs_EntityType> _okTypes;
SMDS_ElemIteratorPtr _iter;
const SMDS_MeshElement * _curElem;
std::vector< SMDSAbs_EntityType> _okTypes;
public:
TFilteringIterator( const vector< SMDSAbs_EntityType>& okTypes,
const SMDS_ElemIteratorPtr& elemIterator)
TFilteringIterator( const std::vector< SMDSAbs_EntityType>& okTypes,
const SMDS_ElemIteratorPtr& elemIterator)
:_iter(elemIterator), _curElem(0), _okTypes(okTypes)
{
next();
@ -282,11 +282,11 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetFaces() const
// ... else elements filtered using allowedTypes are additionally returned
SMDS_ElemIteratorPtr facesIter = GetMeshDS()->elementsIterator(SMDSAbs_Face);
SMDS_ElemIteratorPtr filterIter( new TFilteringIterator( _allowedTypes, facesIter ));
vector< SMDS_ElemIteratorPtr > iters(2);
std::vector< SMDS_ElemIteratorPtr > iters(2);
iters[0] = proxyIter;
iters[1] = filterIter;
typedef vector< SMDS_ElemIteratorPtr > TElemIterVector;
typedef std::vector< SMDS_ElemIteratorPtr > TElemIterVector;
typedef SMDS_IteratorOnIterators<const SMDS_MeshElement *, TElemIterVector> TItersIter;
return SMDS_ElemIteratorPtr( new TItersIter( iters ));
}
@ -431,7 +431,7 @@ void SMESH_ProxyMesh::removeTmpElement( const SMDS_MeshElement* elem )
{
if ( elem && elem->GetID() > 0 )
{
set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.find( elem );
std::set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.find( elem );
if ( i != _elemsInMesh.end() )
{
GetMeshDS()->RemoveFreeElement( elem, 0 );
@ -468,7 +468,7 @@ void SMESH_ProxyMesh::setNode2Node(const SMDS_MeshNode* srcNode,
SubMesh* sm = const_cast<SubMesh*>( subMesh );
if ( !subMesh->_n2n )
sm->_n2n = new TN2NMap;
sm->_n2n->insert( make_pair( srcNode, proxyNode ));
sm->_n2n->insert( std::make_pair( srcNode, proxyNode ));
}
//================================================================================

3
src/SMESHClient/SMESH_Client.cxx
View File

@ -61,6 +61,7 @@ static int MYDEBUG = 0;
namespace
{
using std::runtime_error;
//=======================================================================
//function : FindNode
@ -972,7 +973,7 @@ SMESH_Client::Update(bool theIsClear)
int nbNodes = anIndexes[i++];
// nodes
//ASSERT( nbNodes < 9 );
vector<const SMDS_MeshNode*> aNodes( nbNodes );
std::vector<const SMDS_MeshNode*> aNodes( nbNodes );
for ( int iNode = 0; iNode < nbNodes; iNode++ )
aNodes[ iNode ] = FindNode( mySMDSMesh, anIndexes[i++] );
// change

4
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -118,8 +118,8 @@ namespace
static int FirstHexahedronIds[] = {0,1,2,3,4,5,6,7,0,1,2,3};
static int LastHexahedronIds[] = {1,2,3,0,5,6,7,4,4,5,6,7};
static vector<int> FirstPolygonIds;
static vector<int> LastPolygonIds;
static std::vector<int> FirstPolygonIds;
static std::vector<int> LastPolygonIds;
void ReverseConnectivity( std::vector<vtkIdType> & ids, SMDSAbs_EntityType type,
bool toReverse, // inverse element

115
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

@ -108,6 +108,7 @@
#define MARGIN 11
#define COLONIZE(str) (QString(str).contains(":") > 0 ? QString(str) : QString(str) + " :" )
#define __SHAPE_RGB__ 250, 0, 250
enum TCol {
COL_ALGO = 0, COL_SHAPE, COL_ERROR, COL_SHAPEID, COL_PUBLISHED, COL_BAD_MESH, NB_COLUMNS
@ -147,10 +148,10 @@ namespace SMESH
{
myProperty = vtkProperty::New();
myProperty->SetRepresentationToWireframe();
myProperty->SetColor( 250, 0, 250 );
myProperty->SetAmbientColor( 250, 0, 250 );
myProperty->SetDiffuseColor( 250, 0, 250 );
//myProperty->SetSpecularColor( 250, 0, 250 );
myProperty->SetColor( __SHAPE_RGB__ );
myProperty->SetAmbientColor( __SHAPE_RGB__ );
myProperty->SetDiffuseColor( __SHAPE_RGB__ );
//myProperty->SetSpecularColor( __SHAPE_RGB__ );
myProperty->SetLineWidth( 5 );
}
// -----------------------------------------------------------------------
@ -278,13 +279,18 @@ namespace SMESH
actor = GEOM_Actor::New();
if ( actor ) {
actor->SetShape(shape,0,0);
actor->SetProperty(myProperty);
actor->SetShadingProperty(myProperty);
actor->SetWireframeProperty(myProperty);
actor->SetPreviewProperty(myProperty);
// actor->SetProperty(myProperty);
// actor->SetShadingProperty(myProperty);
// actor->SetWireframeProperty(myProperty);
// actor->SetPreviewProperty(myProperty);
actor->PickableOff();
// if ( shape.ShapeType() == TopAbs_EDGE )
// actor->SubShapeOn();
//
actor->SetWidth( myProperty->GetLineWidth() );
actor->SetIsosWidth( myProperty->GetLineWidth() );
actor->SetIsosColor( __SHAPE_RGB__ );
actor->SetColor( __SHAPE_RGB__ );
// if ( shape.ShapeType() == TopAbs_EDGE )
// actor->SubShapeOn();
myViewWindow->AddActor( actor );
}
}
@ -732,10 +738,11 @@ void SMESHGUI_ComputeDlg_QThread::cancel()
//================================================================================
//================================================================================
SMESHGUI_ComputeDlg_QThreadQDialog::SMESHGUI_ComputeDlg_QThreadQDialog(QWidget * parent,
SMESH::SMESH_Gen_var gen,
SMESH::SMESH_Mesh_var mesh,
GEOM::GEOM_Object_var mainShape)
SMESHGUI_ComputeDlg_QThreadQDialog::
SMESHGUI_ComputeDlg_QThreadQDialog(QWidget * parent,
SMESH::SMESH_Gen_var gen,
SMESH::SMESH_Mesh_var mesh,
GEOM::GEOM_Object_var mainShape)
: QDialog(parent,
Qt::WindowSystemMenuHint |
Qt::WindowCloseButtonHint |
@ -916,23 +923,28 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( !memoryLack )
{
// List of objects that will be updated automatically
QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > > aListToUpdate;
SMESH::SMESH_IDSource_var aMeshObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aMeshSObj );
typedef QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > > TListOf_IDSrc_SObj;
TListOf_IDSrc_SObj aListToUpdate;
SMESH::SMESH_IDSource_var aMeshObj =
SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aMeshSObj );
// put Mesh into list
aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aMeshObj, aMeshSObj) );
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aMeshObj, aMeshSObj ));
SMESH::submesh_array_var aSubMeshes = myMesh->GetSubMeshes();
// put SubMeshes into list
for ( CORBA::ULong i = 0; i < aSubMeshes->length(); i++ ) {
for ( CORBA::ULong i = 0; i < aSubMeshes->length(); i++ )
{
SMESH::SMESH_subMesh_var sm = aSubMeshes[i];
if ( CORBA::is_nil( sm ) ) continue;
_PTR(SObject) smSObj = SMESH::ObjectToSObject( sm );
if ( !smSObj ) continue;
SMESH::SMESH_IDSource_var aSubMeshObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( smSObj );
aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aSubMeshObj, smSObj) );
SMESH::SMESH_IDSource_var aSubMeshObj =
SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( smSObj );
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aSubMeshObj, smSObj ));
}
// put Groups into list
SMESH::ListOfGroups_var aGroups = myMesh->GetGroups();
for ( size_t i = 0; i < aGroups->length(); ++i ) {
SMESH::ListOfGroups_var aGroups = myMesh->GetGroups();
for ( size_t i = 0; i < aGroups->length(); ++i )
{
SMESH::SMESH_GroupBase_var aGrp = aGroups[i];
if ( CORBA::is_nil( aGrp ) ) continue;
SMESH::SMESH_Group_var aStdGroup = SMESH::SMESH_Group::_narrow( aGrp );
@ -941,26 +953,31 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( !aStdGroup->_is_nil() ) continue; // don't update the standalone groups
_PTR(SObject) aGroupSO = SMESH::FindSObject( aGrp );
if ( !aGroupSO ) continue;
SMESH::SMESH_IDSource_var aGroupObj = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aGroupSO );
aListToUpdate.append( QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) >(aGroupObj, aGroupSO) );
SMESH::SMESH_IDSource_var aGroupObj =
SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aGroupSO );
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aGroupObj, aGroupSO ));
}
// update mesh, sub-mesh and groups, if it's possible
QList< QPair< SMESH::SMESH_IDSource_var, _PTR(SObject) > >::iterator anIter;
for( anIter = aListToUpdate.begin(); anIter != aListToUpdate.end(); anIter++ ) {
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( (*anIter).second ));
if ( getSMESHGUI()->automaticUpdate( (*anIter).first, &entities, &limitExceeded, &hidden, &nbElements ) )
TListOf_IDSrc_SObj::iterator anIter;
for ( anIter = aListToUpdate.begin(); anIter != aListToUpdate.end(); anIter++ )
{
SMESH::SMESH_Mesh_var aMesh =
SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( (*anIter).second ));
if ( getSMESHGUI()->automaticUpdate( (*anIter).first, &entities, &limitExceeded,
&hidden, &nbElements ) )
{
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
bool toDisplay = false;
if ( !aMesh->_is_nil() ) { // display a mesh only
if ( !aMesh->_is_nil() ) // display only a mesh
{
toDisplay = true;
SMESH_Actor *anActor = SMESH::FindActorByObject( aMesh );
if ( !anActor ) anActor = SMESH::CreateActor( (*anIter).second->GetStudy(), (*anIter).second->GetID().c_str(), true );
if ( !anActor ) anActor = SMESH::CreateActor( (*anIter).second->GetStudy(),
(*anIter).second->GetID().c_str(),
/*clearLog =*/ true );
if ( anActor ) // actor is not created for an empty mesh
{
anActor->SetEntityMode( entities );
@ -981,7 +998,10 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( hidden & SMESH_Actor::eBallElem ) hiddenMsg << tr( "SMESH_BALLS" );
SUIT_MessageBox::warning( desktop(),
tr( "SMESH_WRN_WARNING" ),
tr( "SMESH_WRN_SIZE_INC_LIMIT_EXCEEDED" ).arg( nbElements ).arg( limitSize ).arg( hiddenMsg.join(", ") ) );
tr( "SMESH_WRN_SIZE_INC_LIMIT_EXCEEDED" ).
arg( nbElements ).
arg( limitSize ).
arg( hiddenMsg.join(", ")));
}
}
catch (...) {
@ -1000,12 +1020,12 @@ void SMESHGUI_BaseComputeOp::computeMesh()
{
SUIT_MessageBox::warning( desktop(),
tr( "SMESH_WRN_WARNING" ),
tr( "SMESH_WRN_SIZE_LIMIT_EXCEEDED" ).arg( nbElements ).arg( limitSize ) );
tr( "SMESH_WRN_SIZE_LIMIT_EXCEEDED" ).
arg( nbElements ).arg( limitSize ) );
}
}
}
LightApp_SelectionMgr *Sel = selectionMgr();
if ( Sel )
if ( LightApp_SelectionMgr *Sel = selectionMgr() )
{
SALOME_ListIO selected;
selected.Append( myIObject );
@ -1017,10 +1037,11 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( memoryLack )
aMemoryReserve.release();
myCompDlg->setWindowTitle(tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED"));
myCompDlg->setWindowTitle
( tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED" ));
// SHOW ERRORS
bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
bool noHypoError = ( aHypErrors.isEmpty() );
@ -1234,8 +1255,9 @@ void SMESHGUI_BaseComputeOp::onPublishShape()
if ( !SMESH::getSubShapeSO( 1, myMainShape )) // the main shape not published
{
QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( myMainShape, "MAIN_SHAPE" ));
SALOMEDS::SObject_wrap so =
geomGen->AddInStudy( study, myMainShape, name.toLatin1().data(), GEOM::GEOM_Object::_nil());
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, myMainShape,
name.toLatin1().data(),
GEOM::GEOM_Object::_nil());
// look for myMainShape in the table
for ( int r = 0, nr = table()->rowCount(); r < nr; ++r ) {
if ( table()->item( r, COL_SHAPEID )->text() == "1" ) {
@ -1252,7 +1274,8 @@ void SMESHGUI_BaseComputeOp::onPublishShape()
if ( curSub == 1 ) continue;
}
QString name = GEOMBase::GetDefaultName( SMESH::shapeTypeName( shape, "ERROR_SHAPE" ));
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, shape, name.toLatin1().data(), myMainShape);
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( study, shape,
name.toLatin1().data(), myMainShape);
if ( !so->_is_nil() ) {
CORBA::String_var name = so->GetName();
CORBA::String_var entry = so->GetID();
@ -1995,7 +2018,8 @@ void SMESHGUI_PrecomputeOp::onPreview()
if ( isShowError )
{
myDlg->hide();
aCompDlg->setWindowTitle(tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED"));
aCompDlg->setWindowTitle
( tr( computeFailed ? "SMESH_WRN_COMPUTE_FAILED" : "SMESH_COMPUTE_SUCCEED" ));
showComputeResult( memoryLack, noCompError, aCompErrors, noHypoError, aHypErrors );
}
}
@ -2198,10 +2222,11 @@ void SMESHGUI_BaseComputeOp::evaluateMesh()
aMemoryReserve.release();
evaluateFailed = ( aCompErrors->length() > 0 );
myCompDlg->setWindowTitle(tr( evaluateFailed ? "SMESH_WRN_EVALUATE_FAILED" : "SMESH_EVALUATE_SUCCEED"));
myCompDlg->setWindowTitle
( tr( evaluateFailed ? "SMESH_WRN_EVALUATE_FAILED" : "SMESH_EVALUATE_SUCCEED" ));
// SHOW ERRORS
bool noCompError = ( !aCompErrors.operator->() || aCompErrors->length() == 0 );
bool noHypoError = ( aHypErrors.isEmpty() );

2
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -1852,7 +1852,7 @@ void SMESHGUI_SplitVolumesDlg::showFacetByElement( int elemID )
gp_XYZ bc( 0,0,0 );
Bnd_B3d bbox;
SMDS_NodeIteratorPtr nIt = elem->nodeIterator();
vector< const SMDS_MeshNode* > nodes;
std::vector< const SMDS_MeshNode* > nodes;
nodes.reserve( elem->NbNodes() );
while ( nIt->more() )
{

18
src/SMESHUtils/SMESH_Comment.hxx
View File

@ -30,40 +30,38 @@
# 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() );
}
SMESH_Comment & operator=(const SMESH_Comment& c) {
_s << c.c_str() ;
this->string::operator=( _s.str() );
this->std::string::operator=( _s.str() );
return *this;
}
template <class T>
SMESH_Comment( const T &anything ) {
_s << anything ;
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 ;
}

8
src/SMESHUtils/SMESH_FreeBorders.cxx
View File

@ -290,7 +290,7 @@ namespace
void BNode::AddClose ( const BEdge* e, double u ) const
{
if ( ! e->Contains( this ))
myCloseEdges.push_back( make_pair( const_cast< BEdge* >( e ), u ));
myCloseEdges.push_back( std::make_pair( const_cast< BEdge* >( e ), u ));
}
BEdge* BNode::GetCloseEdgeOfBorder( int borderID, double * uPtr ) const
{
@ -569,9 +569,9 @@ void SMESH_MeshAlgos::FindCoincidentFreeBorders(SMDS_Mesh& mesh,
// form groups of coincident parts of free borders
TFreeBorderPart part;
TCoincidentGroup group;
vector< BEdge* > ranges; // couples of edges delimiting parts
TFreeBorderPart part;
TCoincidentGroup group;
std::vector< BEdge* > ranges; // couples of edges delimiting parts
BEdge* be = 0; // a current edge
int skipGroup = bEdges.size(); // a group ID used to avoid repeating treatment of edges

2
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -1297,7 +1297,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
TCollection_AsciiString aLongString, aFunctionType;
int where = 1;
set< string > functionNameSet;
std::set< std::string > functionNameSet;
while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType ))
{
// make a python string literal

2
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -1628,7 +1628,7 @@ void ConnectedElements_i::SetThreshold ( const char*
{
case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
{
vector< double > xyz;
std::vector< double > xyz;
char* endptr;
do
{

32
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -71,16 +71,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;
@ -88,18 +88,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 ) {
@ -107,7 +107,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;
@ -125,8 +125,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; // to translate object from persistent to transient form
};
// ===========================================================
@ -568,7 +568,7 @@ public:
typename TInterface::_var_type GetObjectByOldId( const int oldID )
{
if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {
string ior = myStudyContext->getIORbyOldId( oldID );
std::string ior = myStudyContext->getIORbyOldId( oldID );
if ( !ior.empty() )
return TInterface::_narrow(GetORB()->string_to_object( ior.c_str() ));
}
@ -671,13 +671,13 @@ private:
::SMESH_Gen myGen; // SMESH_Gen local implementation
// hypotheses managing
map<string, GenericHypothesisCreator_i*> myHypCreatorMap;
std::map<std::string, GenericHypothesisCreator_i*> myHypCreatorMap;
map<int, StudyContext*> myStudyContextMap; // Map of study context objects
std::map<int, StudyContext*> myStudyContextMap; // Map of study context objects
GEOM_Client* myShapeReader; // Shape reader
SALOMEDS::Study_var myCurrentStudy; // Current study
CORBA::Boolean myIsEmbeddedMode; // Current mode
GEOM_Client* myShapeReader; // Shape reader
SALOMEDS::Study_var myCurrentStudy; // Current study
CORBA::Boolean myIsEmbeddedMode; // Current mode
// Default color of groups
std::string myDefaultGroupColor;

27
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -47,12 +47,12 @@
#ifdef _DEBUG_
static int MYDEBUG = 0;
//static int VARIABLE_DEBUG = 0;
#else
static int MYDEBUG = 0;
//static int VARIABLE_DEBUG = 0;
#endif
using namespace std;
//=============================================================================
/*!
* Get...Tag [ static ]
@ -281,7 +281,8 @@ static SALOMEDS::SObject_ptr publish(SALOMEDS::Study_ptr theStudy,
SALOMEDS::SObject_wrap curObj;
if ( theFatherObject->GetLastChildTag() > theTag )
{
SALOMEDS::UseCaseIterator_wrap anUseCaseIter = useCaseBuilder->GetUseCaseIterator(theFatherObject);
SALOMEDS::UseCaseIterator_wrap
anUseCaseIter = useCaseBuilder->GetUseCaseIterator(theFatherObject);
for ( ; anUseCaseIter->More(); anUseCaseIter->Next() ) {
curObj = anUseCaseIter->Value();
if ( curObj->Tag() > theTag ) {
@ -294,21 +295,29 @@ static SALOMEDS::SObject_ptr publish(SALOMEDS::Study_ptr theStudy,
}
SALOMEDS::GenericAttribute_wrap anAttr;
if ( !CORBA::is_nil( theIOR )) {
if ( !CORBA::is_nil( theIOR ))
{
anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeIOR" );
CORBA::String_var objStr = SMESH_Gen_i::GetORB()->object_to_string( theIOR );
SALOMEDS::AttributeIOR_wrap iorAttr = anAttr;
iorAttr->SetValue( objStr.in() );
// UnRegister() !!!
SALOME::GenericObj_var genObj = SALOME::GenericObj::_narrow( theIOR );
if ( !genObj->_is_nil() )
genObj->UnRegister();
CORBA::String_var objStrCur = iorAttr->Value();
bool sameIOR = ( objStrCur.in() && strcmp( objStr.in(), objStrCur.in() ) == 0 );
if ( !sameIOR )
{
iorAttr->SetValue( objStr.in() );
// UnRegister() !!!
SALOME::GenericObj_var genObj = SALOME::GenericObj::_narrow( theIOR );
if ( !genObj->_is_nil() )
genObj->UnRegister();
}
}
if ( thePixMap ) {
anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributePixMap" );
SALOMEDS::AttributePixMap_wrap pm = anAttr;
pm->SetPixMap( thePixMap );
}
if ( !theSelectable ) {
anAttr = aStudyBuilder->FindOrCreateAttribute( SO, "AttributeSelectable" );
SALOMEDS::AttributeSelectable_wrap selAttr = anAttr;

12
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -502,8 +502,8 @@ namespace
*/
//================================================================================
void getNodesOfElements(SMDS_ElemIteratorPtr elemIt,
set<const SMDS_MeshNode* >& nodes)
void getNodesOfElements(SMDS_ElemIteratorPtr elemIt,
std::set<const SMDS_MeshNode* >& nodes)
{
while ( elemIt->more() )
{
@ -531,7 +531,7 @@ CORBA::Long SMESH_GroupBase_i::GetNumberOfNodes()
{
if ( myNbNodes < 0 || g->GetTic() != myGroupDSTic )
{
set<const SMDS_MeshNode* > nodes;
std::set<const SMDS_MeshNode* > nodes;
getNodesOfElements( g->GetElements(), nodes );
myNbNodes = nodes.size();
myGroupDSTic = g->GetTic();
@ -574,10 +574,10 @@ SMESH::long_array* SMESH_GroupBase_i::GetNodeIDs()
SMESH::long_array_var aRes = new SMESH::long_array();
if ( SMESHDS_GroupBase* g = GetGroupDS())
{
set<const SMDS_MeshNode* > nodes;
std::set<const SMDS_MeshNode* > nodes;
getNodesOfElements( g->GetElements(), nodes );
aRes->length( nodes.size() );
set<const SMDS_MeshNode*>::iterator nIt = nodes.begin(), nEnd = nodes.end();
std::set<const SMDS_MeshNode*>::iterator nIt = nodes.begin(), nEnd = nodes.end();
for ( int i = 0; nIt != nEnd; ++nIt, ++i )
aRes[i] = (*nIt)->GetID();
}
@ -918,7 +918,7 @@ SMESH::long_array* SMESH_GroupOnFilter_i::GetMeshInfo()
if ( g->GetType() != SMDSAbs_Node )
{
vector< int > nbElems = static_cast< SMESHDS_GroupOnFilter* >( g )->GetMeshInfo();
std::vector< int > nbElems = static_cast< SMESHDS_GroupOnFilter* >( g )->GetMeshInfo();
for ( size_t i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
if ( i < nbElems.size() )
aRes[i] = nbElems[ i ];

12
src/SMESH_I/SMESH_Measurements_i.cxx
View File

@ -221,12 +221,12 @@ static void enlargeBoundingBox(const SMDS_MeshNode* theNode,
theMeasure.node1 = theNode->GetID();
}
else {
theMeasure.minX = min( theMeasure.minX, theNode->X() );
theMeasure.maxX = max( theMeasure.maxX, theNode->X() );
theMeasure.minY = min( theMeasure.minY, theNode->Y() );
theMeasure.maxY = max( theMeasure.maxY, theNode->Y() );
theMeasure.minZ = min( theMeasure.minZ, theNode->Z() );
theMeasure.maxZ = max( theMeasure.maxZ, theNode->Z() );
theMeasure.minX = std::min( theMeasure.minX, theNode->X() );
theMeasure.maxX = std::max( theMeasure.maxX, theNode->X() );
theMeasure.minY = std::min( theMeasure.minY, theNode->Y() );
theMeasure.maxY = std::max( theMeasure.maxY, theNode->Y() );
theMeasure.minZ = std::min( theMeasure.minZ, theNode->Z() );
theMeasure.maxZ = std::max( theMeasure.maxZ, theNode->Z() );
}
}

18
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -5249,10 +5249,10 @@ void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump & theDumpPytho
*/
//================================================================================
string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
std::string SMESH_MeshEditor_i::generateGroupName(const std::string& thePrefix)
{
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
set<string> groupNames;
set<std::string> groupNames;
// Get existing group names
for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
@ -5265,7 +5265,7 @@ string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
}
// Find new name
string name = thePrefix;
std::string name = thePrefix;
int index = 0;
while (!groupNames.insert(name).second)
@ -5573,8 +5573,8 @@ SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
// Create group with newly created nodes
SMESH::long_array_var anIds = GetLastCreatedNodes();
if (anIds->length() > 0) {
string anUnindexedName (theNodes->GetName());
string aNewName = generateGroupName(anUnindexedName + "_double");
std::string anUnindexedName (theNodes->GetName());
std::string aNewName = generateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
@ -5672,8 +5672,8 @@ SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
// Create group with newly created nodes
SMESH::long_array_var anIds = GetLastCreatedNodes();
if (anIds->length() > 0) {
string anUnindexedName (theNodes[0]->GetName());
string aNewName = generateGroupName(anUnindexedName + "_double");
std::string anUnindexedName (theNodes[0]->GetName());
std::string aNewName = generateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
@ -5897,7 +5897,7 @@ SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
@ -6129,7 +6129,7 @@ SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();

3
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -37,6 +37,7 @@
#include "SMESH_PythonDump.hxx"
#include "SMESH_MeshEditor.hxx"
#include <list>
#include <string>
class SMESH_Mesh_i;
@ -897,7 +898,7 @@ private: //!< private methods
void dumpGroupsList(SMESH::TPythonDump & theDumpPython,
const SMESH::ListOfGroups * theGroupList);
string generateGroupName(const string& thePrefix);
std::string generateGroupName(const std::string& thePrefix);
void prepareIdSource(SMESH::SMESH_IDSource_ptr theObject);

2
src/SMESH_I/SMESH_Pattern_i.cxx
View File

@ -45,6 +45,8 @@
#include <sstream>
#include <set>
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;

55
src/SMESH_I/SMESH_PreMeshInfo.cxx
View File

@ -54,6 +54,7 @@
#include CORBA_SERVER_HEADER(SALOME_Session)
using namespace std;
#define MYDEBUGOUT(msg) //std::cout << msg << std::endl;
@ -62,7 +63,7 @@ namespace
enum { GroupOnFilter_OutOfDate = -1 };
// a map to count not yet loaded meshes
static map< int, int > theStudyIDToMeshCounter;
static std::map< int, int > theStudyIDToMeshCounter;
//================================================================================
/*!
@ -72,8 +73,8 @@ namespace
void meshInfoLoaded( SMESH_Mesh_i* mesh )
{
map< int, int >::iterator id2counter =
theStudyIDToMeshCounter.insert( make_pair( (int) mesh->GetStudyId(), 0 )).first;
std::map< int, int >::iterator id2counter =
theStudyIDToMeshCounter.insert( std::make_pair( (int) mesh->GetStudyId(), 0 )).first;
id2counter->second++;
}
//================================================================================
@ -88,7 +89,7 @@ namespace
{
if ( --theStudyIDToMeshCounter[ (int) mesh->GetStudyId() ] == 0 )
{
string tmpDir = SALOMEDS_Tool::GetDirFromPath( hdfFile );
std::string tmpDir = SALOMEDS_Tool::GetDirFromPath( hdfFile );
SALOMEDS::ListOfFileNames_var aFiles = new SALOMEDS::ListOfFileNames;
aFiles->length(2);
@ -109,7 +110,7 @@ namespace
class SignalToGUI
{
string _messagePrefix;
std::string _messagePrefix;
SALOME::Session_var _session;
public:
SignalToGUI( SMESH_Mesh_i* mesh )
@ -127,7 +128,7 @@ namespace
_messagePrefix = "SMESH/mesh_loading/";
_messagePrefix += meshEntry.in();
string msgToGUI = _messagePrefix + "/";
std::string msgToGUI = _messagePrefix + "/";
msgToGUI += SMESH_Comment( mesh->NbNodes() );
msgToGUI += "/";
msgToGUI += SMESH_Comment( mesh->NbElements() );
@ -140,7 +141,7 @@ namespace
{
if ( !_messagePrefix.empty() )
{
string msgToGUI = _messagePrefix + "/stop";
std::string msgToGUI = _messagePrefix + "/stop";
_session->emitMessageOneWay( msgToGUI.c_str());
_messagePrefix.clear();
}
@ -173,7 +174,7 @@ namespace
SMDS_PositionPtr vertexPosition() const { return SMDS_PositionPtr( new SMDS_VertexPosition); }
SMDS_PositionPtr defaultPosition() const { return SMDS_SpacePosition::originSpacePosition(); }
typedef SMDS_PositionPtr (PositionCreator:: * FmakePos)() const;
vector<FmakePos> myFuncTable;
std::vector<FmakePos> myFuncTable;
};
//================================================================================
@ -182,12 +183,12 @@ namespace
*/
//================================================================================
vector<int> getSimpleSubMeshIds( SMESHDS_Mesh* meshDS, int shapeId )
std::vector<int> getSimpleSubMeshIds( SMESHDS_Mesh* meshDS, int shapeId )
{
vector<int> ids;
std::vector<int> ids;
list<TopoDS_Shape> shapeQueue( 1, meshDS->IndexToShape( shapeId ));
list<TopoDS_Shape>::iterator shape = shapeQueue.begin();
std::list<TopoDS_Shape> shapeQueue( 1, meshDS->IndexToShape( shapeId ));
std::list<TopoDS_Shape>::iterator shape = shapeQueue.begin();
for ( ; shape != shapeQueue.end(); ++shape )
{
if ( shape->IsNull() ) continue;
@ -222,10 +223,10 @@ namespace
*/
//================================================================================
typedef map< MED::EGeometrieElement, SMDSAbs_EntityType > Tmed2smeshElemTypeMap;
typedef std::map< MED::EGeometrieElement, SMDSAbs_EntityType > Tmed2smeshElemTypeMap;
const Tmed2smeshElemTypeMap& med2smeshElemTypeMap()
{
static map< MED::EGeometrieElement, SMDSAbs_EntityType> med2smeshTypes;
static Tmed2smeshElemTypeMap med2smeshTypes;
if ( med2smeshTypes.empty() )
{
for ( int iG = 0; iG < SMDSEntity_Last; ++iG )
@ -233,7 +234,7 @@ namespace
SMDSAbs_EntityType smdsType = (SMDSAbs_EntityType) iG;
MED::EGeometrieElement medType =
(MED::EGeometrieElement) DriverMED::GetMedGeoType( smdsType );
med2smeshTypes.insert( make_pair( medType, smdsType ));
med2smeshTypes.insert( std::make_pair( medType, smdsType ));
}
}
return med2smeshTypes;
@ -254,7 +255,7 @@ namespace
// change at insertion of new items in the middle.
//const vector<MED::EGeometrieElement>& medTypes = mesh2medElemType();
vector<int> data;
std::vector<int> data;
for ( size_t i = 0; i < meshInfo->length(); ++i )
if ( meshInfo[i] > 0 )
@ -298,7 +299,7 @@ void SMESH_PreMeshInfo::hdf2meshInfo( const std::string& name,
// // array->GetDim( datasetSize );
// int size = dataset->GetSize();
vector<int> info( SMDSEntity_Last * 2, 0 );
std::vector<int> info( SMDSEntity_Last * 2, 0 );
dataset->ReadFromDisk( &info[0] );
dataset->CloseOnDisk();
@ -429,7 +430,7 @@ bool SMESH_PreMeshInfo::readPreInfoFromHDF()
group_i->changePreMeshInfo() = newInstance();
if ( SMESHDS_GroupBase* group = group_i->GetGroupDS() )
{
const string name = group->GetStoreName();
const std::string name = group->GetStoreName();
group_i->changePreMeshInfo()->hdf2meshInfo( name, infoHdfGroup );
}
}
@ -499,7 +500,7 @@ void SMESH_PreMeshInfo::readGroupInfo()
if ( _mesh->_mapGroups.empty() ) return;
// make SMESH_PreMeshInfo of groups
map< string, SMESH_PreMeshInfo* > name2GroupInfo;
map< std::string, SMESH_PreMeshInfo* > name2GroupInfo;
map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i2group = _mesh->_mapGroups.begin();
for ( ; i2group != _mesh->_mapGroups.end(); ++i2group )
{
@ -510,8 +511,8 @@ void SMESH_PreMeshInfo::readGroupInfo()
group_i->changePreMeshInfo() = info;
if ( SMESHDS_Group* group = dynamic_cast< SMESHDS_Group* >( group_i->GetGroupDS() ))
{
string name = group->GetStoreName();
name2GroupInfo.insert( make_pair( name, info ));
std::string name = group->GetStoreName();
name2GroupInfo.insert( std::make_pair( name, info ));
info->_isInfoOk = true;
}
}
@ -534,8 +535,8 @@ void SMESH_PreMeshInfo::readGroupInfo()
vector< SMESH_PreMeshInfo* >& grInfoVec = famId2grInfo[ medFamInfo->GetId() ];
for ( int iG = 0; iG < nbGroups; ++iG )
{
const string grName = medFamInfo->GetGroupName( iG );
map< string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.find( grName );
const std::string grName = medFamInfo->GetGroupName( iG );
map< std::string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.find( grName );
if ( n2i != name2GroupInfo.end() )
grInfoVec.push_back( n2i->second );
}
@ -560,14 +561,14 @@ void SMESH_PreMeshInfo::readGroupInfo()
f2infos = famId2grInfo.find( famNums[i] );
if ( f2infos == famId2grInfo.end() )
f2infos = famId2grInfo.insert
( make_pair( famNums[i], vector< SMESH_PreMeshInfo*>())).first;
( std::make_pair( famNums[i], vector< SMESH_PreMeshInfo*>())).first;
}
vector< SMESH_PreMeshInfo* >& infoVec = f2infos->second ;
for ( size_t j = 0; j < infoVec.size(); ++j )
infoVec[j]->_elemCounter++;
}
// pass _elemCounter to a real elem type
map< string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.begin();
map< std::string, SMESH_PreMeshInfo* >::iterator n2i = name2GroupInfo.begin();
for ( ; n2i != name2GroupInfo.end(); ++n2i )
{
SMESH_PreMeshInfo* info = n2i->second;
@ -618,7 +619,7 @@ void SMESH_PreMeshInfo::readSubMeshInfo()
for ( int isNode = 0; isNode < 2; ++isNode )
{
string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
std::string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
{
// read sub-mesh id of all nodes or elems
@ -893,7 +894,7 @@ void SMESH_PreMeshInfo::readSubMeshes(DriverMED_R_SMESHDS_Mesh* reader) const
SMDS_ElemIteratorPtr eIt = meshDS->elementsIterator();
for ( int isNode = 0; isNode < 2; ++isNode )
{
string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
std::string aDSName( isNode ? "Node Submeshes" : "Element Submeshes");
if ( aGroup->ExistInternalObject( (char*) aDSName.c_str() ))
{
HDFdataset* aDataset = new HDFdataset( (char*) aDSName.c_str(), aGroup );

1
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -58,6 +58,7 @@
#include <set>
#include <vector>
using namespace std;
#ifdef _DEBUG_
// #define DEB_FACES

18
src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
View File

@ -57,15 +57,15 @@ public:
private:
bool findBoxFaces( const TopoDS_Shape& shape,
list< _QuadFaceGrid >& boxFaceContainer,
SMESH_Mesh& mesh,
_QuadFaceGrid * & fBottom,
_QuadFaceGrid * & fTop,
_QuadFaceGrid * & fFront,
_QuadFaceGrid * & fBack,
_QuadFaceGrid * & fLeft,
_QuadFaceGrid * & fRight);
bool findBoxFaces( const TopoDS_Shape& shape,
std::list< _QuadFaceGrid >& boxFaceContainer,
SMESH_Mesh& mesh,
_QuadFaceGrid * & fBottom,
_QuadFaceGrid * & fTop,
_QuadFaceGrid * & fFront,
_QuadFaceGrid * & fBack,
_QuadFaceGrid * & fLeft,
_QuadFaceGrid * & fRight);
};
#endif

22
src/StdMeshers/StdMeshers_FaceSide.cxx
View File

@ -56,6 +56,8 @@
#include "utilities.h"
using namespace std;
//================================================================================
/*!
* \brief Constructor of a side of one edge
@ -71,7 +73,7 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
const bool theIgnoreMediumNodes,
SMESH_ProxyMesh::Ptr theProxyMesh)
{
list<TopoDS_Edge> edges(1,theEdge);
std::list<TopoDS_Edge> edges(1,theEdge);
*this = StdMeshers_FaceSide( theFace, edges, theMesh, theIsForward,
theIgnoreMediumNodes, theProxyMesh );
}
@ -82,12 +84,12 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
*/
//================================================================================
StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh,
const bool theIsForward,
const bool theIgnoreMediumNodes,
SMESH_ProxyMesh::Ptr theProxyMesh)
StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
std::list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh,
const bool theIsForward,
const bool theIgnoreMediumNodes,
SMESH_ProxyMesh::Ptr theProxyMesh)
{
int nbEdges = theEdges.size();
myEdge.resize ( nbEdges );
@ -112,7 +114,7 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
SMESHDS_Mesh* meshDS = myProxyMesh->GetMeshDS();
int nbDegen = 0;
list<TopoDS_Edge>::iterator edge = theEdges.begin();
std::list<TopoDS_Edge>::iterator edge = theEdges.begin();
for ( int index = 0; edge != theEdges.end(); ++index, ++edge )
{
int i = theIsForward ? index : nbEdges-index-1;
@ -302,8 +304,8 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec& theSideNodes,
*/
//================================================================================
const vector<UVPtStruct>& StdMeshers_FaceSide::GetUVPtStruct(bool isXConst,
double constValue) const
const std::vector<UVPtStruct>& StdMeshers_FaceSide::GetUVPtStruct(bool isXConst,
double constValue) const
{
if ( myPoints.empty() )
{

2
src/StdMeshers/StdMeshers_Geometric1D.cxx
View File

@ -166,7 +166,7 @@ bool StdMeshers_Geometric1D::SetParametersByMesh(const SMESH_Mesh* theMesh,
const TopoDS_Edge& edge = TopoDS::Edge( edgeMap( i ));
BRepAdaptor_Curve C( edge );
vector< double > params;
std::vector< double > params;
if ( SMESH_Algo::GetNodeParamOnEdge( theMesh->GetMeshDS(), edge, params ))
{
nbEdges++;

2
src/StdMeshers/StdMeshers_HexaFromSkin_3D.cxx
View File

@ -33,6 +33,8 @@
#include <limits>
using namespace std;
// Define error message and _MYDEBUG_ if needed
#ifdef _DEBUG_
#define BAD_MESH_ERR \

2
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -270,7 +270,7 @@ private:
TParam2ColumnMap* myParamToColumnMap;
PSurface mySurface;
TopoDS_Edge myBaseEdge;
map< int, PSurface > myShapeID2Surf;
std::map< int, PSurface > myShapeID2Surf;
// first and last normalized params and orientaion for each component or it-self
std::vector< std::pair< double, double> > myParams; // select my columns in myParamToColumnMap
bool myIsForward;

1
src/StdMeshers/StdMeshers_Projection_3D.cxx
View File

@ -57,6 +57,7 @@
namespace TAssocTool = StdMeshers_ProjectionUtils;
using namespace std;
//=======================================================================
//function : StdMeshers_Projection_3D

2
src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
View File

@ -61,6 +61,8 @@
#include <list>
#include <vector>
using namespace std;
//================================================================================
/*!
* \brief 1D algo

2
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -82,7 +82,7 @@ struct FaceQuadStruct
return GetUVPtStruct()[ to-nbNodeOut-(IsReversed() ? -1 : +1)];
}
// some sortcuts
const vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
{ return nbNodeOut ?
grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
grid->GetUVPtStruct( isXConst, constValue );

17
src/StdMeshers/StdMeshers_SegmentAroundVertex_0D.cxx
View File

@ -38,7 +38,7 @@ StdMeshers_SegmentAroundVertex_0D::StdMeshers_SegmentAroundVertex_0D
:SMESH_0D_Algo(hypId, studyId, gen)
{
_name = "SegmentAroundVertex_0D";
// it is assigned to vertices but influence a state of EDGE submeshes
// it is assigned to vertices but influence a state of EDGE submeshes
_shapeType = (1 << TopAbs_VERTEX); // 1 bit per shape type
_compatibleHypothesis.push_back("SegmentLengthAroundVertex");
@ -55,16 +55,17 @@ StdMeshers_SegmentAroundVertex_0D::~StdMeshers_SegmentAroundVertex_0D()
//=======================================================================
//function : CheckHypothesis
//purpose :
//purpose :
//=======================================================================
bool StdMeshers_SegmentAroundVertex_0D::CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus)
bool StdMeshers_SegmentAroundVertex_0D::
CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus)
{
list <const SMESHDS_Hypothesis * >::const_iterator itl;
std::list <const SMESHDS_Hypothesis * >::const_iterator itl;
const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
const std::list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
if ( hyps.size() == 0 )
{
aStatus = SMESH_Hypothesis::HYP_MISSING;
@ -84,7 +85,7 @@ bool StdMeshers_SegmentAroundVertex_0D::CheckHypothesis(SMESH_Mesh&
//=======================================================================
//function : Compute
//purpose :
//purpose :
//=======================================================================
bool StdMeshers_SegmentAroundVertex_0D::Compute(SMESH_Mesh&, const TopoDS_Shape&)

12
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx
View File

@ -178,8 +178,8 @@ void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_arra
CORBA::Short axis)
throw (SALOME::SALOME_Exception)
{
vector<string> funVec;
vector<double> pointVec;
std::vector<std::string> funVec;
std::vector<double> pointVec;
_array2vec( spaceFunctions, funVec, (const char*) );
_array2vec( internalPoints, pointVec, );
@ -209,8 +209,8 @@ void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out
{
ASSERT( myBaseImpl );
try {
vector<string> funVec;
vector<double> pointVec;
std::vector<std::string> funVec;
std::vector<double> pointVec;
this->GetImpl()->GetGridSpacing( funVec, pointVec, axis );
xSpaceFunctions = new SMESH::string_array();
@ -394,8 +394,8 @@ StdMeshers_CartesianParameters3D_i::ComputeCoordinates(CORBA::Double
const char* axisName )
throw (SALOME::SALOME_Exception)
{
vector<string> xFuns;
vector<double> xPoints, coords;
std::vector<std::string> xFuns;
std::vector<double> xPoints, coords;
_array2vec( spaceFuns, xFuns, (const char*) );
_array2vec( points, xPoints, );

2
src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
View File

@ -111,7 +111,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() ));
}

2
src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx
View File

@ -79,7 +79,7 @@ void StdMeshers_Reversible1D_i::SetReversedEdges( const SMESH::long_array& theId
void StdMeshers_Reversible1D_i::SetObjectEntry( const char* theEntry )
{
string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
std::string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
try {
this->GetImpl()->SetObjectEntry( entry.c_str() );
// Update Python script