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

Merge branch 'master' into gni/adaptation

Browse Source
This commit is contained in:
GERALD NICOLAS 2020-12-09 16:11:12 +01:00
commit 665d037f93
272 changed files with 1267 additions and 1804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -232,7 +232,7 @@ IF(WIN32)
SET(SALOME_SMESH_ENABLE_MEFISTO ON) SET(SALOME_SMESH_ENABLE_MEFISTO ON)
MESSAGE(STATUS "Build MEFISTO2D mesher using Fortran to C generator") MESSAGE(STATUS "Build MEFISTO2D mesher using Fortran to C generator")
ELSE(${F2C_FOUND}) ELSE(${F2C_FOUND})
MESSAGE(STATUS "Fortran to C generator is not found: MEFISTO2D mesher will be unavailable.") MESSAGE(FATAL "Fortran to C generator is not found: MEFISTO2D mesher cannot be compiled! Please define F2C_ROOT_DIR !")
ENDIF(${F2C_FOUND}) ENDIF(${F2C_FOUND})
ENDIF(WIN32) ENDIF(WIN32)

6
src/Controls/SMESH_Controls.cxx
View File

@ -2045,7 +2045,7 @@ double Deflection2D::GetBadRate( double Value, int /*nbNodes*/ ) const
*/ */
//================================================================================ //================================================================================
double MultiConnection::GetValue( const TSequenceOfXYZ& P ) double MultiConnection::GetValue( const TSequenceOfXYZ& /*P*/ )
{ {
return 0; return 0;
} }
@ -2072,7 +2072,7 @@ SMDSAbs_ElementType MultiConnection::GetType() const
*/ */
//================================================================================ //================================================================================
double MultiConnection2D::GetValue( const TSequenceOfXYZ& P ) double MultiConnection2D::GetValue( const TSequenceOfXYZ& /*P*/ )
{ {
return 0; return 0;
} }
@ -4263,7 +4263,7 @@ private:
bool isOutOfFace (const gp_Pnt& p); bool isOutOfFace (const gp_Pnt& p);
bool isOutOfEdge (const gp_Pnt& p); bool isOutOfEdge (const gp_Pnt& p);
bool isOutOfVertex(const gp_Pnt& p); bool isOutOfVertex(const gp_Pnt& p);
bool isOutOfNone (const gp_Pnt& p) { return true; } bool isOutOfNone (const gp_Pnt& /*p*/) { return true; }
bool isBox (const TopoDS_Shape& s); bool isBox (const TopoDS_Shape& s);
TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid ); TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid );

6
src/Controls/SMESH_ControlsDef.hxx
View File

@ -129,7 +129,7 @@ namespace SMESH{
NumericalFunctor(); NumericalFunctor();
virtual void SetMesh( const SMDS_Mesh* theMesh ); virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual double GetValue( long theElementId ); virtual double GetValue( long theElementId );
virtual double GetValue(const TSequenceOfXYZ& thePoints) { return -1.0;}; virtual double GetValue(const TSequenceOfXYZ& /*thePoints*/) { return -1.0;};
void GetHistogram(int nbIntervals, void GetHistogram(int nbIntervals,
std::vector<int>& nbEvents, std::vector<int>& nbEvents,
std::vector<double>& funValues, std::vector<double>& funValues,
@ -1214,8 +1214,8 @@ namespace SMESH{
protected: protected:
PredicatePtr myPredicate; PredicatePtr myPredicate;
}; };
}; }
}; }
#endif #endif

8
src/Driver/Driver_Mesh.cxx
View File

@ -123,15 +123,15 @@ std::string Driver_Mesh::fixUTF8(const std::string & str )
// how many bytes follow? // how many bytes follow?
int len = 0; int len = 0;
if (s[i] >> 5 == 0b110 ) len = 1; if (s[i] >> 5 == 0b110 ) len = 1; // todo: binary constants are a GCC extension
else if (s[i] >> 4 == 0b1110 ) len = 2; else if (s[i] >> 4 == 0b1110 ) len = 2; // todo: binary constants are a GCC extension
else if (s[i] >> 3 == 0b11110) len = 3; else if (s[i] >> 3 == 0b11110) len = 3; // todo: binary constants are a GCC extension
else else
invalid = true; invalid = true;
// check the bytes // check the bytes
for ( int j = 0; j < len && !invalid; ++j ) for ( int j = 0; j < len && !invalid; ++j )
invalid = ( s[i+j+1] >> 6 != 0b10 ); invalid = ( s[i+j+1] >> 6 != 0b10 ); // todo: binary constants are a GCC extension
if ( invalid ) if ( invalid )
fixed[i] = '?'; fixed[i] = '?';

4
src/Driver/Driver_Mesh.h
View File

@ -63,8 +63,8 @@ class MESHDRIVER_EXPORT Driver_Mesh
virtual void SetMeshName(const std::string& theMeshName); virtual void SetMeshName(const std::string& theMeshName);
virtual std::string GetMeshName() const; virtual std::string GetMeshName() const;
virtual void SetOption(const std::string& optionName, virtual void SetOption(const std::string& /*optionName*/,
const std::string& optionValue) {} const std::string& /*optionValue*/) {}
virtual Status Perform() = 0; virtual Status Perform() = 0;

10
src/DriverCGNS/DriverCGNS_Read.cxx
View File

@ -134,12 +134,12 @@ namespace
ids[2] = ids[0] + _sizeX + 1; ids[2] = ids[0] + _sizeX + 1;
ids[3] = ids[0] + ( k==_sizeZ ? _sizeX : 1); ids[3] = ids[0] + ( k==_sizeZ ? _sizeX : 1);
} }
void IEdgeNodes( int i, int j, int k, cgsize_t* ids ) const // edge perpendiculaire to X (2D) void IEdgeNodes( int i, int j, int /*k*/, cgsize_t* ids ) const // edge perpendiculaire to X (2D)
{ {
ids[0] = NodeID( i, j, 0 ); ids[0] = NodeID( i, j, 0 );
ids[1] = ids[0] + _sizeX; ids[1] = ids[0] + _sizeX;
} }
void JEdgeNodes( int i, int j, int k, cgsize_t* ids ) const void JEdgeNodes( int i, int j, int /*k*/, cgsize_t* ids ) const
{ {
ids[0] = NodeID( i, j, 0 ); ids[0] = NodeID( i, j, 0 );
ids[1] = ids[0] + 1; ids[1] = ids[0] + 1;
@ -187,7 +187,7 @@ namespace
} }
gp_XYZ Next() gp_XYZ Next()
{ {
gp_XYZ res( _cur[0], _cur[1], _cur[2] ); gp_XYZ res( _cur[0], _cur[1], _cur[2] ); // todo: _cur can be used uninitialized
for ( int i = 0; i < _dim; ++i ) for ( int i = 0; i < _dim; ++i )
{ {
_cur[i] += _dir[i]; _cur[i] += _dir[i];
@ -207,7 +207,7 @@ namespace
size *= _dir[i]*(_end[i]-_beg[i]); size *= _dir[i]*(_end[i]-_beg[i]);
return size; return size;
} }
gp_XYZ Begin() const { return gp_XYZ( _beg[0], _beg[1], _beg[2] ); } gp_XYZ Begin() const { return gp_XYZ( _beg[0], _beg[1], _beg[2] ); } // todo: _beg can be used uninitialized
//gp_XYZ End() const { return gp_XYZ( _end[0]-1, _end[1]-1, _end[2]-1 ); } //gp_XYZ End() const { return gp_XYZ( _end[0]-1, _end[1]-1, _end[2]-1 ); }
}; };
@ -297,7 +297,7 @@ namespace
} }
// fill nodeReplacementMap // fill nodeReplacementMap
TPointRangeIterator rangeIt1( range, _meshDim ); TPointRangeIterator rangeIt1( range, _meshDim ); // todo: rangeIt1: _end[i], _dir[i], _beg[i], _cur[i] may be used uninitialized
TPointRangeIterator rangeIt2( donorRange, _meshDim ); TPointRangeIterator rangeIt2( donorRange, _meshDim );
gp_XYZ begin1 = rangeIt1.Begin(), begin2 = rangeIt2.Begin(), index1, index2; gp_XYZ begin1 = rangeIt1.Begin(), begin2 = rangeIt2.Begin(), index1, index2;
if ( &zone2 == this ) if ( &zone2 == this )

10
src/DriverGMF/libmesh5.c
View File

@ -78,7 +78,7 @@ typedef struct
static int GmfIniFlg=0; static int GmfIniFlg=0;
static GmfMshSct *GmfMshTab[ MaxMsh + 1 ]; static GmfMshSct *GmfMshTab[ MaxMsh + 1 ];
// see MeshGems/Docs/meshgems_formats_description.pdf /* see MeshGems/Docs/meshgems_formats_description.pdf */
static const char *GmfKwdFmt[ GmfMaxKwd + 1 ][4] = static const char *GmfKwdFmt[ GmfMaxKwd + 1 ][4] =
{ {"Reserved", "", "", ""}, { {"Reserved", "", "", ""},
{"MeshVersionFormatted", "", "", "i"}, {"MeshVersionFormatted", "", "", "i"},
@ -875,7 +875,7 @@ void GmfSetLin(int MshIdx, int KwdCod, ...)
{ {
for(i=0;i<kwd->SolSiz;i++) for(i=0;i<kwd->SolSiz;i++)
if(kwd->fmt[i] == 'r') if(kwd->fmt[i] == 'r')
fprintf(msh->hdl, "%.15lg ", va_arg(VarArg, double)); fprintf(msh->hdl, "%.15lg ", va_arg(VarArg, double)); /* todo: ISO C90 does not support the '%lg' gnu_printf format */
else if(kwd->fmt[i] == 'n') { else if(kwd->fmt[i] == 'n') {
nb_repeat = va_arg(VarArg, int); nb_repeat = va_arg(VarArg, int);
fprintf(msh->hdl, "%d ", nb_repeat); fprintf(msh->hdl, "%d ", nb_repeat);
@ -936,7 +936,7 @@ void GmfSetLin(int MshIdx, int KwdCod, ...)
if(msh->typ & Asc) if(msh->typ & Asc)
for(j=0;j<kwd->SolSiz;j++) for(j=0;j<kwd->SolSiz;j++)
fprintf(msh->hdl, "%.15lg ", DblSolTab[j]); fprintf(msh->hdl, "%.15lg ", DblSolTab[j]); /* todo: ISO C90 does not support the '%lg' gnu_printf format */
else else
RecBlk(msh, (unsigned char *)DblSolTab, kwd->NmbWrd); RecBlk(msh, (unsigned char *)DblSolTab, kwd->NmbWrd);
} }
@ -1064,7 +1064,7 @@ static int ScaKwdTab(GmfMshSct *msh)
{ {
/* Search which kwd code this string is associated with, /* Search which kwd code this string is associated with,
then get its header and save the current position in file (just before the data) */ then get its header and save the current position in file (just before the data) */
// printf("libmesh ScaKwdTab %s\n", str); /* printf("libmesh ScaKwdTab %s\n", str); */
for(KwdCod=1; KwdCod<= GmfMaxKwd; KwdCod++) for(KwdCod=1; KwdCod<= GmfMaxKwd; KwdCod++)
if(!strcmp(str, GmfKwdFmt[ KwdCod ][0])) if(!strcmp(str, GmfKwdFmt[ KwdCod ][0]))
{ {
@ -1191,7 +1191,7 @@ static void ExpFmt(GmfMshSct *msh, int KwdCod)
i = kwd->SolSiz = kwd->NmbWrd = 0; i = kwd->SolSiz = kwd->NmbWrd = 0;
while(i < strlen(InpFmt)) while(i < (int)strlen(InpFmt))
{ {
chr = InpFmt[ i++ ]; chr = InpFmt[ i++ ];

12
src/DriverGMF/libmesh5.h
View File

@ -18,7 +18,15 @@
/* Defines */ /* Defines */
/*----------------------------------------------------------*/ /*----------------------------------------------------------*/
#include "SMESH_DriverGMF.hxx" #ifdef WIN32
#if defined MESHDriverGMF_EXPORTS || defined MeshDriverGMF_EXPORTS
#define MESHDriverGMF_EXPORT __declspec( dllexport )
#else
#define MESHDriverGMF_EXPORT __declspec( dllimport )
#endif
#else
#define MESHDriverGMF_EXPORT
#endif
#define GmfStrSiz 1024 #define GmfStrSiz 1024
#define GmfMaxTyp 1000 #define GmfMaxTyp 1000
@ -33,7 +41,7 @@
#define GmfFloat 1 #define GmfFloat 1
#define GmfDouble 2 #define GmfDouble 2
// see MeshGems/Docs/meshgems_formats_description.pdf /* see MeshGems/Docs/meshgems_formats_description.pdf */
enum GmfKwdCod enum GmfKwdCod
{ {
GmfReserved1, \ GmfReserved1, \

2
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -156,7 +156,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
else else
_dblValues.reserve( nbElems * nbComps ); _dblValues.reserve( nbElems * nbComps );
return nbElems * nbComps; return nbElems && nbComps;
} }
//================================================================================ //================================================================================

4
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -112,7 +112,7 @@ void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
myAllSubMeshes = true; myAllSubMeshes = true;
} }
void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID) void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int /*theID*/)
{ {
mySubMeshes.push_back( theSubMesh ); mySubMeshes.push_back( theSubMesh );
} }
@ -379,7 +379,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
if ( myAutoDimension && aMeshDimension < 3 ) if ( myAutoDimension && aMeshDimension < 3 )
{ {
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
double aBounds[6]; double aBounds[6] = {0.,0.,0.,0.,0.,0.};
if(aNodesIter->more()){ if(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next(); const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = aBounds[1] = aNode->X(); aBounds[0] = aBounds[1] = aNode->X();

2
src/DriverUNV/UNV164_Structure.hxx
View File

@ -88,7 +88,7 @@ namespace UNV164
MESHDRIVERUNV_EXPORT void MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream ); Write(std::ofstream& out_stream );
}; }
#endif #endif

2
src/DriverUNV/UNV2411_Structure.hxx
View File

@ -49,7 +49,7 @@ namespace UNV2411{
MESHDRIVERUNV_EXPORT void MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream, const TDataSet& theDataSet); Write(std::ofstream& out_stream, const TDataSet& theDataSet);
}; }
#endif #endif

2
src/DriverUNV/UNV2412_Structure.hxx
View File

@ -65,7 +65,7 @@ namespace UNV2412{
MESHDRIVERUNV_EXPORT bool MESHDRIVERUNV_EXPORT bool
IsVolume(int theFeDescriptorId); IsVolume(int theFeDescriptorId);
}; }
#endif #endif

2
src/DriverUNV/UNV2417_Structure.hxx
View File

@ -46,7 +46,7 @@ namespace UNV2417{
void ReadGroup(const std::string& myGroupLabel, std::ifstream& in_stream, TDataSet& theDataSet); void ReadGroup(const std::string& myGroupLabel, std::ifstream& in_stream, TDataSet& theDataSet);
void Write(std::ofstream& out_stream, const TDataSet& theDataSet); void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
}; }
#endif #endif

2
src/DriverUNV/UNV2420_Structure.hxx
View File

@ -113,7 +113,7 @@ namespace UNV2420
const std::string& part_name); // can store a mesh name const std::string& part_name); // can store a mesh name
// const TDataSet& theDataSet); // const TDataSet& theDataSet);
}; }
#endif #endif

2
src/DriverUNV/UNV_Utilities.hxx
View File

@ -141,7 +141,7 @@ namespace UNV {
resLine.resize( resLine.size()-1 ); resLine.resize( resLine.size()-1 );
return resLine; return resLine;
} }
}; }
#ifndef MESSAGE #ifndef MESSAGE

6
src/MEDWrapper/MED_Algorithm.cxx
View File

@ -28,8 +28,8 @@
static int MYDEBUG = 0; static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0;
#else #else
static int MYDEBUG = 0; static int MYDEBUG = 0; // todo: unused in release mode
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif #endif
namespace MED namespace MED
@ -178,7 +178,7 @@ namespace MED
//--------------------------------------------------------------- //---------------------------------------------------------------
TEntity2FamilySet TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper, GetEntity2FamilySet(const PWrapper& /*theWrapper*/,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo, const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet) const TFamilyInfoSet& theFamilyInfoSet)
{ {

4
src/MEDWrapper/MED_Common.cxx
View File

@ -65,8 +65,8 @@ namespace MED
TInt TInt
GetNbConn(EGeometrieElement typmai, GetNbConn(EGeometrieElement typmai,
EEntiteMaillage typent, EEntiteMaillage /*typent*/,
TInt mdim) TInt /*mdim*/)
{ {
return typmai % 100; return typmai % 100;
} }

2
src/MEDWrapper/MED_CoordUtils.cxx
View File

@ -36,7 +36,7 @@ namespace MED
template<> template<>
TFloat TFloat
GetCoord<eNone>(const TCCoordSlice& theCoordSlice) GetCoord<eNone>(const TCCoordSlice& /*theCoordSlice*/)
{ {
return 0.0; return 0.0;
} }

4
src/MEDWrapper/MED_GaussUtils.cxx
View File

@ -27,8 +27,8 @@
static int MYDEBUG = 0; static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0;
#else #else
static int MYDEBUG = 0; static int MYDEBUG = 0; // todo: unused in release mode
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif #endif
namespace MED namespace MED

9
src/MEDWrapper/MED_Structures.cxx
View File

@ -352,10 +352,10 @@ namespace MED
TGaussInfo::TLess TGaussInfo::TLess
::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const ::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
{ {
if(!&theLeft) if(!&theLeft) // todo: address of reference can be assumed always non-null by compiler
return true; return true;
if(!&theRight) if(!&theRight) // todo: address of reference can be assumed always non-null by compiler
return false; return false;
if(theLeft.myGeom != theRight.myGeom) if(theLeft.myGeom != theRight.myGeom)
@ -644,13 +644,14 @@ namespace MED
switch(aDim){ switch(aDim){
case 3: case 3:
aCoord[2] = myCoord[aDim*theId+2]; aCoord[2] = myCoord[aDim*theId+2];
// fall through
case 2: case 2:
aCoord[1] = myCoord[aDim*theId+1]; aCoord[1] = myCoord[aDim*theId+1];
case 1:{ // fall through
case 1:
aCoord[0] = myCoord[aDim*theId]; aCoord[0] = myCoord[aDim*theId];
break; break;
} }
}
} else { } else {
TFloatVector aVecX = this->GetIndexes(0); TFloatVector aVecX = this->GetIndexes(0);

2
src/MEDWrapper/MED_TStructures.hxx
View File

@ -930,7 +930,7 @@ namespace MED
const TGeom2Size& theGeom2Size, const TGeom2Size& theGeom2Size,
const TGeom2NbGauss& theGeom2NbGauss, const TGeom2NbGauss& theGeom2NbGauss,
TInt theNumDt, TInt theNumDt,
TInt theNumOrd, TInt /*theNumOrd*/,
TFloat theDt, TFloat theDt,
const std::string& theUnitDt, const std::string& theUnitDt,
const TGeom2Gauss& theGeom2Gauss) const TGeom2Gauss& theGeom2Gauss)

4
src/MEDWrapper/MED_Utilities.cxx
View File

@ -26,7 +26,7 @@
#ifdef _DEBUG_ #ifdef _DEBUG_
static int MYDEBUG = 0; static int MYDEBUG = 0;
#else #else
static int MYDEBUG = 0; static int MYDEBUG = 0; // todo: unused in release mode
#endif #endif
int MED::PrefixPrinter::myCounter = 0; int MED::PrefixPrinter::myCounter = 0;
@ -39,7 +39,7 @@ MED::PrefixPrinter::PrefixPrinter(bool theIsActive):
MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter); MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
} }
MED::PrefixPrinter::~PrefixPrinter() MED::PrefixPrinter::~PrefixPrinter() noexcept(false)
{ {
if(myIsActive){ if(myIsActive){
myCounter--; myCounter--;

2
src/MEDWrapper/MED_Utilities.hxx
View File

@ -39,7 +39,7 @@ namespace MED
bool myIsActive; bool myIsActive;
public: public:
PrefixPrinter(bool theIsActive = true); PrefixPrinter(bool theIsActive = true);
~PrefixPrinter(); ~PrefixPrinter() noexcept(false);
static std::string GetPrefix(); static std::string GetPrefix();
}; };

18
src/MEDWrapper/MED_Wrapper.cxx
View File

@ -38,8 +38,8 @@
static int MYDEBUG = 0; static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0;
#else #else
static int MYDEBUG = 0; static int MYDEBUG = 0; // todo: unused in release mode
static int MYVALUEDEBUG = 0; static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif #endif
namespace MED namespace MED
@ -630,7 +630,7 @@ namespace MED
void void
TWrapper TWrapper
::GetNames(TElemInfo& theInfo, ::GetNames(TElemInfo& theInfo,
TInt theNb, TInt /*theNb*/,
EEntiteMaillage theEntity, EEntiteMaillage theEntity,
EGeometrieElement theGeom, EGeometrieElement theGeom,
TErr* theErr) TErr* theErr)
@ -721,7 +721,7 @@ namespace MED
void void
TWrapper TWrapper
::GetNumeration(TElemInfo& theInfo, ::GetNumeration(TElemInfo& theInfo,
TInt theNb, TInt /*theNb*/,
EEntiteMaillage theEntity, EEntiteMaillage theEntity,
EGeometrieElement theGeom, EGeometrieElement theGeom,
TErr* theErr) TErr* theErr)
@ -812,7 +812,7 @@ namespace MED
void void
TWrapper TWrapper
::GetFamilies(TElemInfo& theInfo, ::GetFamilies(TElemInfo& theInfo,
TInt theNb, TInt /*theNb*/,
EEntiteMaillage theEntity, EEntiteMaillage theEntity,
EGeometrieElement theGeom, EGeometrieElement theGeom,
TErr* theErr) TErr* theErr)
@ -2323,7 +2323,7 @@ namespace MED
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
EGeometrieElement EGeometrieElement
TWrapper TWrapper
::GetBallGeom(const TMeshInfo& theMeshInfo) ::GetBallGeom(const TMeshInfo& /*theMeshInfo*/)
{ {
TErr anError; TErr anError;
TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor); TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
@ -2763,7 +2763,7 @@ namespace MED
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void void
TWrapper TWrapper
::GetGaussInfo(TInt theId, ::GetGaussInfo(TInt /*theId*/,
TGaussInfo& theInfo, TGaussInfo& theInfo,
TErr* theErr) TErr* theErr)
{ {
@ -3127,7 +3127,7 @@ namespace MED
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void void
TWrapper TWrapper
::GetProfileInfo(TInt theId, ::GetProfileInfo(TInt /*theId*/,
TProfileInfo& theInfo, TProfileInfo& theInfo,
TErr* theErr) TErr* theErr)
{ {
@ -4006,7 +4006,7 @@ namespace MED
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
PGrilleInfo PGrilleInfo
TWrapper TWrapper
::CrGrilleInfo(const PMeshInfo& theMeshInfo) ::CrGrilleInfo(const PMeshInfo& /*theMeshInfo*/)
{ {
return PGrilleInfo(); // not implemented???? return PGrilleInfo(); // not implemented????
} }

2
src/MEDWrapper/mprint_version.cxx
View File

@ -43,6 +43,6 @@ int main (int argc, char **argv)
minor = release = -1; minor = release = -1;
} }
printf("%d.%d.%d\n", major, minor, release); printf("%d.%d.%d\n", (int)major, (int)minor, (int)release);
return 0; return 0;
} }

2
src/MEFISTO2/aptrte.cxx
View File

@ -760,7 +760,7 @@ void
#endif #endif
#endif #endif
qualitetrte( R3 *mnpxyd, qualitetrte( R3 *mnpxyd,
Z & mosoar, Z & mxsoar, Z *mnsoar, Z & mosoar, Z & /*mxsoar*/, Z *mnsoar,
Z & moartr, Z & mxartr, Z *mnartr, Z & moartr, Z & mxartr, Z *mnartr,
Z & nbtria, R & quamoy, R & quamin ) Z & nbtria, R & quamoy, R & quamin )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2
src/OBJECT/SMESH_Actor.cxx
View File

@ -1914,7 +1914,7 @@ int SMESH_ActorDef::RenderTranslucentGeometry(vtkViewport *vp)
} }
void SMESH_ActorDef::Render(vtkRenderer *ren) void SMESH_ActorDef::Render(vtkRenderer* /*ren*/)
{ {
vtkMTimeType aTime = myTimeStamp->GetMTime(); vtkMTimeType aTime = myTimeStamp->GetMTime();
vtkMTimeType anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime(); vtkMTimeType anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();

2
src/OBJECT/SMESH_Actor.h
View File

@ -56,7 +56,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
static SMESH_Actor* New() { return NULL;} static SMESH_Actor* New() { return NULL;}
public: public:
vtkTypeMacro(SMESH_Actor,SALOME_Actor); vtkTypeMacro(SMESH_Actor,SALOME_Actor)
static SMESH_Actor* New(TVisualObjPtr theVisualObj, static SMESH_Actor* New(TVisualObjPtr theVisualObj,
const char* theEntry, const char* theEntry,
const char* theName, const char* theName,

2
src/OBJECT/SMESH_ActorDef.h
View File

@ -83,7 +83,7 @@ class SMESH_ActorDef : public SMESH_Actor
friend class SMESH_Actor; friend class SMESH_Actor;
public: public:
vtkTypeMacro(SMESH_ActorDef,SMESH_Actor); vtkTypeMacro(SMESH_ActorDef,SMESH_Actor)
virtual void Delete(); virtual void Delete();

4
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -44,7 +44,7 @@
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
#include <vtkCellData.h> #include <vtkCellData.h>
vtkStandardNewMacro(SMESH_CellLabelActor); vtkStandardNewMacro(SMESH_CellLabelActor)
/*! /*!
Constructor. Constructor.
@ -205,7 +205,7 @@ void SMESH_CellLabelActor::UpdateLabels()
void SMESH_CellLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject), void SMESH_CellLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
unsigned long theEvent, unsigned long /*theEvent*/,
void* theClientData, void* theClientData,
void* vtkNotUsed(theCallData)) void* vtkNotUsed(theCallData))
{ {

2
src/OBJECT/SMESH_CellLabelActor.h
View File

@ -49,7 +49,7 @@ public:
void* theCallData); void* theCallData);
vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor); vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor)
virtual void SetCellsLabeled(bool theIsCellsLabeled); virtual void SetCellsLabeled(bool theIsCellsLabeled);

8
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -77,7 +77,7 @@ static int MYDEBUG = 0;
using namespace std; using namespace std;
vtkStandardNewMacro(SMESH_DeviceActor); vtkStandardNewMacro(SMESH_DeviceActor)
SMESH_DeviceActor SMESH_DeviceActor
@ -410,7 +410,7 @@ SMESH_DeviceActor
aNbCells = 0; aNbCells = 0;
for(; anIter != aValues.end(); anIter++){ for(; anIter != aValues.end(); anIter++){
const Length2D::Value& aValue = *anIter; const Length2D::Value& aValue = *anIter;
int aNode[2] = { vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]), myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1]) myVisualObj->GetNodeVTKId(aValue.myPntId[1])
}; };
@ -475,7 +475,7 @@ SMESH_DeviceActor
aNbCells = 0; aNbCells = 0;
for(; anIter != aValues.end(); anIter++){ for(; anIter != aValues.end(); anIter++){
const MultiConnection2D::Value& aValue = (*anIter).first; const MultiConnection2D::Value& aValue = (*anIter).first;
int aNode[2] = { vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]), myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1]) myVisualObj->GetNodeVTKId(aValue.myPntId[1])
}; };
@ -573,7 +573,7 @@ SMESH_DeviceActor
FreeEdges::TBorders::const_iterator anIter = aBorders.begin(); FreeEdges::TBorders::const_iterator anIter = aBorders.begin();
for(; anIter != aBorders.end(); anIter++){ for(; anIter != aBorders.end(); anIter++){
const FreeEdges::Border& aBorder = *anIter; const FreeEdges::Border& aBorder = *anIter;
int aNode[2] = { vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aBorder.myPntId[0]), myVisualObj->GetNodeVTKId(aBorder.myPntId[0]),
myVisualObj->GetNodeVTKId(aBorder.myPntId[1]) myVisualObj->GetNodeVTKId(aBorder.myPntId[1])
}; };

2
src/OBJECT/SMESH_DeviceActor.h
View File

@ -61,7 +61,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
friend class SMESH_ActorDef; friend class SMESH_ActorDef;
public: public:
vtkTypeMacro(SMESH_DeviceActor,vtkLODActor); vtkTypeMacro(SMESH_DeviceActor,vtkLODActor)
static SMESH_DeviceActor* New(); static SMESH_DeviceActor* New();
void SetStoreClippingMapping(bool theStoreMapping); void SetStoreClippingMapping(bool theStoreMapping);

2
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -48,7 +48,7 @@ using namespace std;
#endif #endif
vtkStandardNewMacro(SMESH_ExtractGeometry); vtkStandardNewMacro(SMESH_ExtractGeometry)
SMESH_ExtractGeometry::SMESH_ExtractGeometry() SMESH_ExtractGeometry::SMESH_ExtractGeometry()

2
src/OBJECT/SMESH_ExtractGeometry.h
View File

@ -32,7 +32,7 @@
class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{ class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{
public: public:
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry); vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry)
static SMESH_ExtractGeometry *New(); static SMESH_ExtractGeometry *New();

4
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -42,7 +42,7 @@
#define PI 3.14159265359 #define PI 3.14159265359
vtkStandardNewMacro(SMESH_FaceOrientationFilter); vtkStandardNewMacro(SMESH_FaceOrientationFilter)
/*! /*!
* \class SMESH_FaceOrientationFilter * \class SMESH_FaceOrientationFilter
@ -237,7 +237,7 @@ void GetFaceParams( vtkCell* theFace, double theNormal[3], double& theSize )
* Execute method. Output calculation. * Execute method. Output calculation.
*/ */
int SMESH_FaceOrientationFilter::RequestData( int SMESH_FaceOrientationFilter::RequestData(
vtkInformation *request, vtkInformation * /*request*/,
vtkInformationVector **inputVector, vtkInformationVector **inputVector,
vtkInformationVector *outputVector) vtkInformationVector *outputVector)
{ {

2
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

@ -33,7 +33,7 @@ class VTKViewer_CellCenters;
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{ {
public: public:
vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm ); vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm )
/*!Create a new SMESH_FaceOrientationFilter.*/ /*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New(); static SMESH_FaceOrientationFilter *New();

4
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -39,7 +39,7 @@
#include <vtkRenderer.h> #include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
vtkStandardNewMacro(SMESH_NodeLabelActor); vtkStandardNewMacro(SMESH_NodeLabelActor)
/*! /*!
Constructor. Constructor.
@ -195,7 +195,7 @@ void SMESH_NodeLabelActor::UpdateLabels()
void SMESH_NodeLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject), void SMESH_NodeLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
unsigned long theEvent, unsigned long /*theEvent*/,
void* theClientData, void* theClientData,
void* vtkNotUsed(theCallData)) void* vtkNotUsed(theCallData))
{ {

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

@ -46,7 +46,7 @@ public:
void* theCallData); void* theCallData);
vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor); vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor)
virtual void SetPointsLabeled(bool theIsPointsLabeled); virtual void SetPointsLabeled(bool theIsPointsLabeled);

2
src/OBJECT/SMESH_SVTKActor.cxx
View File

@ -43,7 +43,7 @@
#include <Utils_SALOME_Exception.hxx> #include <Utils_SALOME_Exception.hxx>
vtkStandardNewMacro(SMESH_SVTKActor); vtkStandardNewMacro(SMESH_SVTKActor)
/*! /*!
Constructor Constructor

2
src/OBJECT/SMESH_SVTKActor.h
View File

@ -41,7 +41,7 @@ class SMESHOBJECT_EXPORT SMESH_SVTKActor : public SVTK_Actor {
public: public:
static SMESH_SVTKActor* New(); static SMESH_SVTKActor* New();
vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor); vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor)
void SetBallScale(double theSize); void SetBallScale(double theSize);
void SetBallSize(float theSize); void SetBallSize(float theSize);

8
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -41,11 +41,11 @@
#define SHRINK_COEF 0.08; #define SHRINK_COEF 0.08;
vtkStandardNewMacro(SMESH_ScalarBarActor); vtkStandardNewMacro(SMESH_ScalarBarActor)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors); vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty); vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty); vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty)
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label // Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label

2
src/OBJECT/SMESH_ScalarBarActor.h
View File

@ -91,7 +91,7 @@ class SMESHOBJECT_EXPORT SMESH_ScalarBarActor: public vtkActor2D {
public: public:
void PrintSelf(ostream& os, vtkIndent indent); void PrintSelf(ostream& os, vtkIndent indent);
vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D); vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D)
// Description: // Description:
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label // Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label

2
src/PluginUtils/GeomSelectionTools.h
View File

@ -72,7 +72,7 @@ public:
namespace PluginUtils namespace PluginUtils
{ {
PLUGINUTILS_EXPORT QString PrintDoubleValue( double, int = 16 ); PLUGINUTILS_EXPORT QString PrintDoubleValue( double, int = 16 );
}; }
#endif // _GEOMSELECTIONTOOLS_H_ #endif // _GEOMSELECTIONTOOLS_H_

34
src/SMDS/SMDS_Downward.cxx
View File

@ -122,7 +122,7 @@ int SMDS_Downward::addCell(int vtkId)
* *
* @param cellId * @param cellId
*/ */
void SMDS_Downward::initCell(int cellId) void SMDS_Downward::initCell(int /*cellId*/)
{ {
} }
@ -131,7 +131,7 @@ void SMDS_Downward::initCell(int cellId)
* @param cellId not used here. * @param cellId not used here.
* @return * @return
*/ */
int SMDS_Downward::getNumberOfDownCells(int cellId) int SMDS_Downward::getNumberOfDownCells(int /*cellId*/)
{ {
return _nbDownCells; return _nbDownCells;
} }
@ -154,7 +154,7 @@ const int* SMDS_Downward::getDownCells(int cellId)
* @param cellId index of the cell in the downward structure relative to a vtk cell type. * @param cellId index of the cell in the downward structure relative to a vtk cell type.
* @return table of downward entities types. * @return table of downward entities types.
*/ */
const unsigned char* SMDS_Downward::getDownTypes(int cellId) const unsigned char* SMDS_Downward::getDownTypes(int /*cellId*/)
{ {
return &_cellTypes[0]; return &_cellTypes[0];
} }
@ -165,7 +165,7 @@ const unsigned char* SMDS_Downward::getDownTypes(int cellId)
* @param lowCellId index of the children cell to add (dimension n-1) * @param lowCellId index of the children cell to add (dimension n-1)
* @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add). * @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
*/ */
void SMDS_Downward::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_Downward::addDownCell(int /*cellId*/, int /*lowCellId*/, unsigned char /*aType*/)
{ {
ASSERT(0); // must be re-implemented in derived class ASSERT(0); // must be re-implemented in derived class
} }
@ -176,12 +176,12 @@ void SMDS_Downward::addDownCell(int cellId, int lowCellId, unsigned char aType)
* @param upCellId index of the parent cell to add (dimension n+1) * @param upCellId index of the parent cell to add (dimension n+1)
* @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add). * @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
*/ */
void SMDS_Downward::addUpCell(int cellId, int upCellId, unsigned char aType) void SMDS_Downward::addUpCell(int /*cellId*/, int /*upCellId*/, unsigned char /*aType*/)
{ {
ASSERT(0); // must be re-implemented in derived class ASSERT(0); // must be re-implemented in derived class
} }
int SMDS_Downward::getNodeSet(int cellId, int* nodeSet) int SMDS_Downward::getNodeSet(int /*cellId*/, int* /*nodeSet*/)
{ {
return 0; return 0;
} }
@ -777,17 +777,17 @@ void SMDS_Down3D::compactStorage()
// nothing to do, size was known before // nothing to do, size was known before
} }
int SMDS_Down3D::getNumberOfUpCells(int cellId) int SMDS_Down3D::getNumberOfUpCells(int /*cellId*/)
{ {
return 0; return 0;
} }
const int* SMDS_Down3D::getUpCells(int cellId) const int* SMDS_Down3D::getUpCells(int /*cellId*/)
{ {
return 0; return 0;
} }
const unsigned char* SMDS_Down3D::getUpTypes(int cellId) const unsigned char* SMDS_Down3D::getUpTypes(int /*cellId*/)
{ {
return 0; return 0;
} }
@ -904,7 +904,7 @@ void SMDS_DownTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesType& e
edgesWithNodes.elems[2].vtkType = VTK_LINE; edgesWithNodes.elems[2].vtkType = VTK_LINE;
} }
void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_LINE); //ASSERT(aType == VTK_LINE);
@ -961,7 +961,7 @@ void SMDS_DownQuadTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesTyp
edgesWithNodes.elems[2].vtkType = VTK_QUADRATIC_EDGE; edgesWithNodes.elems[2].vtkType = VTK_QUADRATIC_EDGE;
} }
void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_EDGE); //ASSERT(aType == VTK_QUADRATIC_EDGE);
@ -1021,7 +1021,7 @@ void SMDS_DownQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesType&
edgesWithNodes.elems[3].vtkType = VTK_LINE; edgesWithNodes.elems[3].vtkType = VTK_LINE;
} }
void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_LINE); //ASSERT(aType == VTK_LINE);
@ -1085,7 +1085,7 @@ void SMDS_DownQuadQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesT
edgesWithNodes.elems[3].vtkType = VTK_QUADRATIC_EDGE; edgesWithNodes.elems[3].vtkType = VTK_QUADRATIC_EDGE;
} }
void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_EDGE); //ASSERT(aType == VTK_QUADRATIC_EDGE);
@ -1150,7 +1150,7 @@ void SMDS_DownTetra::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& o
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]); MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
} }
void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_TRIANGLE); //ASSERT(aType == VTK_TRIANGLE);
@ -1258,7 +1258,7 @@ void SMDS_DownQuadTetra::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]); MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
} }
void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_TRIANGLE); //ASSERT(aType == VTK_QUADRATIC_TRIANGLE);
@ -2006,7 +2006,7 @@ void SMDS_DownHexa::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& or
MESSAGE(nodes[4] << " " << nodes[5] << " " << nodes[6] << " " << nodes[7]); MESSAGE(nodes[4] << " " << nodes[5] << " " << nodes[6] << " " << nodes[7]);
} }
void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
int *faces = &_cellIds[_nbDownCells * cellId]; int *faces = &_cellIds[_nbDownCells * cellId];
@ -2137,7 +2137,7 @@ void SMDS_DownQuadHexa::getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]); MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
} }
void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char aType) void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{ {
//ASSERT((cellId >=0)&& (cellId < _maxId)); //ASSERT((cellId >=0)&& (cellId < _maxId));
int *faces = &_cellIds[_nbDownCells * cellId]; int *faces = &_cellIds[_nbDownCells * cellId];

4
src/SMDS/SMDS_Downward.hxx
View File

@ -77,8 +77,8 @@ public:
virtual const int* getUpCells(int cellId) = 0; virtual const int* getUpCells(int cellId) = 0;
virtual const unsigned char* getUpTypes(int cellId) = 0; virtual const unsigned char* getUpTypes(int cellId) = 0;
virtual void getNodeIds(int cellId, std::set<int>& nodeSet) = 0; virtual void getNodeIds(int cellId, std::set<int>& nodeSet) = 0;
virtual int getNodes(int cellId, int* nodevec) {return 0; } virtual int getNodes(int /*cellId*/, int* /*nodevec*/) {return 0; }
virtual void getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& orderedNodes) {}; virtual void getOrderedNodesOfFace(int /*cellId*/, std::vector<vtkIdType>& /*orderedNodes*/) {};
int getVtkCellId(int cellId) int getVtkCellId(int cellId)
{ {
return _vtkCellIds[cellId]; return _vtkCellIds[cellId];

4
src/SMDS/SMDS_ElementFactory.hxx
View File

@ -231,7 +231,7 @@ struct _RangeSet
* \brief Return ranges of indices (from,to) of elements having a given value * \brief Return ranges of indices (from,to) of elements having a given value
*/ */
bool GetIndices( const attr_t theValue, TIndexRanges & theIndices, bool GetIndices( const attr_t theValue, TIndexRanges & theIndices,
const attr_t* theMinValue = 0, const attr_t* theMaxValue = 0) const const attr_t* /*theMinValue*/ = 0, const attr_t* /*theMaxValue*/ = 0) const
{ {
bool isFound = false; bool isFound = false;
@ -417,7 +417,7 @@ public:
{ min = false; max = true; return myUsedRanges; } { min = false; max = true; return myUsedRanges; }
//! Return ranges of elements assigned to sub-shapes and min/max of sub-shape IDs //! Return ranges of elements assigned to sub-shapes and min/max of sub-shape IDs
const TSubIDRangeSet& GetSubIDRangesMinMax( int& min, int& max ) const const TSubIDRangeSet& GetSubIDRangesMinMax( int& /*min*/, int& /*max*/ ) const
{ /*min = myMinSubID; max = myMaxSubID;*/ return mySubIDRanges; } { /*min = myMinSubID; max = myMaxSubID;*/ return mySubIDRanges; }
//! Minimize allocated memory //! Minimize allocated memory

2
src/SMDS/SMDS_MemoryLimit.cxx
View File

@ -33,7 +33,7 @@
#include <iostream> #include <iostream>
#endif #endif
int main (int argc, char ** argv) int main ()
{ {
// To better understand what is going on here, consult bug [SALOME platform 0019911] // To better understand what is going on here, consult bug [SALOME platform 0019911]
#if !defined WIN32 && !defined __APPLE__ #if !defined WIN32 && !defined __APPLE__

2
src/SMDS/SMDS_Mesh.cxx
View File

@ -68,7 +68,7 @@ int SMDS_Mesh::chunkSize = 1024;
*/ */
//================================================================================ //================================================================================
int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) int SMDS_Mesh::CheckMemory(const bool doNotRaise)
{ {
return -1; return -1;
#if !defined WIN32 && !defined __APPLE__ #if !defined WIN32 && !defined __APPLE__

2
src/SMDS/SMDS_Mesh.hxx
View File

@ -679,7 +679,7 @@ public:
* \param doNotRaise - if true, suppress exception, just return free memory size * \param doNotRaise - if true, suppress exception, just return free memory size
* \retval int - amount of available memory in MB or negative number in failure case * \retval int - amount of available memory in MB or negative number in failure case
*/ */
static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc); static int CheckMemory(const bool doNotRaise=false);
virtual int MaxNodeID() const; virtual int MaxNodeID() const;
virtual int MinNodeID() const; virtual int MinNodeID() const;

2
src/SMDS/SMDS_MeshGroup.hxx
View File

@ -41,7 +41,7 @@ class SMDS_EXPORT SMDS_MeshGroup: public SMDS_MeshObject, SMDS_ElementHolder
void SetType (const SMDSAbs_ElementType theType); void SetType (const SMDSAbs_ElementType theType);
void Clear(); void Clear();
void Reserve(size_t nbElems) {} void Reserve(size_t /*nbElems*/) {}
bool Add(const SMDS_MeshElement * theElem); bool Add(const SMDS_MeshElement * theElem);
bool Remove(const SMDS_MeshElement * theElem); bool Remove(const SMDS_MeshElement * theElem);
bool IsEmpty() const { return myElements.empty(); } bool IsEmpty() const { return myElements.empty(); }

2
src/SMDS/SMDS_MeshNode.hxx
View File

@ -62,7 +62,7 @@ class SMDS_EXPORT SMDS_MeshNode: public SMDS_MeshElement
virtual bool IsPoly() const { return false; } virtual bool IsPoly() const { return false; }
virtual bool IsQuadratic() const { return false; } virtual bool IsQuadratic() const { return false; }
virtual bool IsMediumNode(const SMDS_MeshNode* node) const { return false; } virtual bool IsMediumNode(const SMDS_MeshNode* /*node*/) const { return false; }
virtual int NbCornerNodes() const { return 1; } virtual int NbCornerNodes() const { return 1; }
void Print(std::ostream & OS) const; void Print(std::ostream & OS) const;

2
src/SMDS/SMDS_MeshVolume.cxx
View File

@ -201,7 +201,7 @@ int SMDS_MeshVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
} }
return -1; return -1;
} }
bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes*/[], const int /*nbNodes*/)
{ {
return false; return false;
} }

2
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
View File

@ -40,7 +40,7 @@ class SMDS_EXPORT SMDS_PolygonalFaceOfNodes : public SMDS_CellOfNodes
virtual SMDSAbs_GeometryType GetGeomType() const { return SMDSGeom_POLYGON; } virtual SMDSAbs_GeometryType GetGeomType() const { return SMDSGeom_POLYGON; }
virtual bool IsPoly() const { return true; } virtual bool IsPoly() const { return true; }
virtual bool IsQuadratic() const { return false; } virtual bool IsQuadratic() const { return false; }
virtual bool IsMediumNode(const SMDS_MeshNode* node) const { return false; } virtual bool IsMediumNode(const SMDS_MeshNode* /*node*/) const { return false; }
virtual int NbCornerNodes() const { return NbNodes(); } virtual int NbCornerNodes() const { return NbNodes(); }
virtual int NbNodes() const; virtual int NbNodes() const;

2
src/SMDS/SMDS_Position.hxx
View File

@ -62,7 +62,7 @@ class SMDS_Ptr : public std::unique_ptr< T >
SMDS_Ptr( T * pos = (T *) 0, bool isOwner=true ): SMDS_Ptr( T * pos = (T *) 0, bool isOwner=true ):
std::unique_ptr< T >( pos ), myIsOwner( isOwner ) {} std::unique_ptr< T >( pos ), myIsOwner( isOwner ) {}
SMDS_Ptr( const SMDS_Ptr& from ) : myIsOwner( from.myIsOwner ) SMDS_Ptr( const SMDS_Ptr& from ) : std::unique_ptr< T >(), myIsOwner( from.myIsOwner )
{ this->swap( const_cast<SMDS_Ptr&>( from )); } { this->swap( const_cast<SMDS_Ptr&>( from )); }
SMDS_Ptr& operator=( const SMDS_Ptr& from ) SMDS_Ptr& operator=( const SMDS_Ptr& from )

2
src/SMDS/SMDS_SetIterator.hxx
View File

@ -63,7 +63,7 @@ namespace SMDS {
template <typename VALUE> template <typename VALUE>
struct PassAllValueFilter struct PassAllValueFilter
{ {
bool operator()(const VALUE& t ) { return true; } bool operator()(const VALUE& /*t*/ ) { return true; }
}; };
template <typename VALUE> template <typename VALUE>

5
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -336,7 +336,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
} }
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints, void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& idNodesOldToNew, std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied, int& alreadyCopied,
int start, int start,
int end) int end)
@ -410,7 +410,7 @@ void SMDS_UnstructuredGrid::CleanDownwardConnectivity()
* Downward connectivity is no more valid if vtkUnstructuredGrid is modified. * Downward connectivity is no more valid if vtkUnstructuredGrid is modified.
* *
*/ */
void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
{ {
MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2); MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2);
// TODO calcul partiel sans edges // TODO calcul partiel sans edges
@ -482,6 +482,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges)
GuessSize[VTK_QUADRATIC_HEXAHEDRON] = nbQuadHexa; GuessSize[VTK_QUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_TRIQUADRATIC_HEXAHEDRON] = nbQuadHexa; GuessSize[VTK_TRIQUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_HEXAGONAL_PRISM] = nbHexPrism; GuessSize[VTK_HEXAGONAL_PRISM] = nbHexPrism;
(void)GuessSize; // unused in Release mode
_downArray[VTK_LINE] ->allocate(nbLineGuess); _downArray[VTK_LINE] ->allocate(nbLineGuess);
_downArray[VTK_QUADRATIC_EDGE] ->allocate(nbQuadEdgeGuess); _downArray[VTK_QUADRATIC_EDGE] ->allocate(nbQuadEdgeGuess);

44
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -1488,10 +1488,10 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_TETRA: case QUAD_TETRA:
{ {
switch ( minInd ) { switch ( minInd ) {
case 0: if( maxInd==4 || maxInd==6 || maxInd==7 ) return true; case 0: if( maxInd==4 || maxInd==6 || maxInd==7 ) return true; // fall through
case 1: if( maxInd==4 || maxInd==5 || maxInd==8 ) return true; case 1: if( maxInd==4 || maxInd==5 || maxInd==8 ) return true; // fall through
case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true; case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true; // fall through
case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) return true; case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) return true; // fall through
default:; default:;
} }
break; break;
@ -1499,14 +1499,14 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_HEXA: case QUAD_HEXA:
{ {
switch ( minInd ) { switch ( minInd ) {
case 0: if( maxInd==8 || maxInd==11 || maxInd==16 ) return true; case 0: if( maxInd==8 || maxInd==11 || maxInd==16 ) return true; // fall through
case 1: if( maxInd==8 || maxInd==9 || maxInd==17 ) return true; case 1: if( maxInd==8 || maxInd==9 || maxInd==17 ) return true; // fall through
case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true; case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true; // fall through
case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true; case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true; // fall through
case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true; case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true; // fall through
case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true; case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true; // fall through
case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true; case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true; // fall through
case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) return true; case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) return true; // fall through
default:; default:;
} }
break; break;
@ -1514,10 +1514,10 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_PYRAM: case QUAD_PYRAM:
{ {
switch ( minInd ) { switch ( minInd ) {
case 0: if( maxInd==5 || maxInd==8 || maxInd==9 ) return true; case 0: if( maxInd==5 || maxInd==8 || maxInd==9 ) return true; // fall through
case 1: if( maxInd==5 || maxInd==6 || maxInd==10 ) return true; case 1: if( maxInd==5 || maxInd==6 || maxInd==10 ) return true; // fall through
case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true; case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true; // fall through
case 3: if( maxInd==7 || maxInd==8 || maxInd==12 ) return true; case 3: if( maxInd==7 || maxInd==8 || maxInd==12 ) return true; // fall through
case 4: if( maxInd==9 || maxInd==10 || maxInd==11 || maxInd==12 ) return true; case 4: if( maxInd==9 || maxInd==10 || maxInd==11 || maxInd==12 ) return true;
default:; default:;
} }
@ -1526,12 +1526,12 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_PENTA: case QUAD_PENTA:
{ {
switch ( minInd ) { switch ( minInd ) {
case 0: if( maxInd==6 || maxInd==8 || maxInd==12 ) return true; case 0: if( maxInd==6 || maxInd==8 || maxInd==12 ) return true; // fall through
case 1: if( maxInd==6 || maxInd==7 || maxInd==13 ) return true; case 1: if( maxInd==6 || maxInd==7 || maxInd==13 ) return true; // fall through
case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true; case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true; // fall through
case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true; case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true; // fall through
case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true; case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true; // fall through
case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) return true; case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) return true; // fall through
default:; default:;
} }
break; break;

10
src/SMESH/SMESH_Algo.cxx
View File

@ -518,7 +518,7 @@ GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge& theE1,
OCC_CATCH_SIGNALS; OCC_CATCH_SIGNALS;
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol); return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
} }
catch (Standard_Failure) { catch (Standard_Failure&) {
} }
return GeomAbs_C0; return GeomAbs_C0;
} }
@ -858,7 +858,7 @@ bool SMESH_Algo::Compute(SMESH_Mesh & /*aMesh*/, SMESH_MesherHelper* /*aHelper*/
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{ {
return true; return true;
} }
@ -1261,7 +1261,7 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh,
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
} }
@ -1271,7 +1271,7 @@ bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
} }
@ -1281,7 +1281,7 @@ bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
} }

15
src/SMESH/SMESH_Gen.cxx
View File

@ -142,7 +142,6 @@ SMESH_Gen::~SMESH_Gen()
//============================================================================= //=============================================================================
SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode) SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode)
throw(SALOME_Exception)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
@ -453,8 +452,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
* Prepare Compute a mesh * Prepare Compute a mesh
*/ */
//============================================================================= //=============================================================================
void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape) const TopoDS_Shape & /*aShape*/)
{ {
_compute_canceled = false; _compute_canceled = false;
resetCurrentSubMesh(); resetCurrentSubMesh();
@ -465,8 +464,8 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
* Cancel Compute a mesh * Cancel Compute a mesh
*/ */
//============================================================================= //=============================================================================
void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape) const TopoDS_Shape & /*aShape*/)
{ {
_compute_canceled = true; _compute_canceled = true;
if ( const SMESH_subMesh* sm = GetCurrentSubMesh() ) if ( const SMESH_subMesh* sm = GetCurrentSubMesh() )
@ -1053,10 +1052,10 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths()
} }
// get a separator from rootDir // get a separator from rootDir
for ( pos = strlen( rootDir )-1; pos >= 0 && sep.empty(); --pos ) for ( int i = strlen( rootDir )-1; i >= 0 && sep.empty(); --i )
if ( rootDir[pos] == '/' || rootDir[pos] == '\\' ) if ( rootDir[i] == '/' || rootDir[i] == '\\' )
{ {
sep = rootDir[pos]; sep = rootDir[i];
break; break;
} }
#ifdef WIN32 #ifdef WIN32

3
src/SMESH/SMESH_Gen.hxx
View File

@ -67,8 +67,7 @@ public:
SMESH_Gen(); SMESH_Gen();
~SMESH_Gen(); ~SMESH_Gen();
SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode) SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
throw(SALOME_Exception);
enum ComputeFlags enum ComputeFlags
{ {

8
src/SMESH/SMESH_HypoFilter.cxx
View File

@ -57,7 +57,7 @@ bool SMESH_HypoFilter::NamePredicate::IsOk (const SMESH_Hypothesis* aHyp,
int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const
{ {
return aHyp->GetType(); return aHyp->GetType();
}; }
//======================================================================= //=======================================================================
//function : DimPredicate::Value //function : DimPredicate::Value
@ -78,7 +78,7 @@ bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
const TopoDS_Shape& /*aShape*/) const const TopoDS_Shape& /*aShape*/) const
{ {
return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType ); return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
}; }
//======================================================================= //=======================================================================
//function : IsAuxiliaryPredicate::IsOk //function : IsAuxiliaryPredicate::IsOk
@ -89,7 +89,7 @@ bool SMESH_HypoFilter::IsAuxiliaryPredicate::IsOk(const SMESH_Hypothesis* aHyp,
const TopoDS_Shape& /*aShape*/) const const TopoDS_Shape& /*aShape*/) const
{ {
return aHyp->IsAuxiliary(); return aHyp->IsAuxiliary();
}; }
//======================================================================= //=======================================================================
//function : ApplicablePredicate::ApplicablePredicate //function : ApplicablePredicate::ApplicablePredicate
@ -117,7 +117,7 @@ bool SMESH_HypoFilter::InstancePredicate::IsOk(const SMESH_Hypothesis* aHyp,
//purpose : //purpose :
//======================================================================= //=======================================================================
bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp, bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* /*aHyp*/,
const TopoDS_Shape& aShape) const const TopoDS_Shape& aShape) const
{ {
return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape )); return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape ));

2
src/SMESH/SMESH_HypoFilter.hxx
View File

@ -107,7 +107,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
enum Logical { AND, AND_NOT, OR, OR_NOT }; enum Logical { AND, AND_NOT, OR, OR_NOT };
enum Comparison { EQUAL, NOT_EQUAL, MORE, LESS }; enum Comparison { EQUAL, NOT_EQUAL, MORE, LESS };
SMESH_HypoFilter(const SMESH_HypoFilter& other){} SMESH_HypoFilter(const SMESH_HypoFilter& /*other*/){}
void add( Logical bool_op, SMESH_HypoPredicate* pred ) void add( Logical bool_op, SMESH_HypoPredicate* pred )
{ {

130
src/SMESH/SMESH_Mesh.cxx
View File

@ -618,7 +618,7 @@ SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName,
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape, SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
int anHypId, int anHypId,
std::string* anError ) throw(SALOME_Exception) std::string* anError )
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis"); if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
@ -713,7 +713,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape, SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
int anHypId) throw( SALOME_Exception ) int anHypId)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis"); if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
@ -784,7 +784,6 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
const std::list<const SMESHDS_Hypothesis*>& const std::list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{ {
return _myMeshDS->GetHypothesis(aSubShape); return _myMeshDS->GetHypothesis(aSubShape);
} }
@ -993,7 +992,7 @@ SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const int anHypId) const
*/ */
//============================================================================= //=============================================================================
const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception) const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetScript()->GetCommands(); return _myMeshDS->GetScript()->GetCommands();
@ -1004,7 +1003,7 @@ const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
* *
*/ */
//============================================================================= //=============================================================================
void SMESH_Mesh::ClearLog() throw(SALOME_Exception) void SMESH_Mesh::ClearLog()
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
_myMeshDS->GetScript()->Clear(); _myMeshDS->GetScript()->Clear();
@ -1017,7 +1016,6 @@ void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
//============================================================================= //=============================================================================
SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape) SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
throw(SALOME_Exception)
{ {
int index = _myMeshDS->ShapeToIndex(aSubShape); int index = _myMeshDS->ShapeToIndex(aSubShape);
if ( !index && aSubShape.IsNull() ) if ( !index && aSubShape.IsNull() )
@ -1070,7 +1068,6 @@ SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
//============================================================================= //=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{ {
int index = _myMeshDS->ShapeToIndex(aSubShape); int index = _myMeshDS->ShapeToIndex(aSubShape);
return GetSubMeshContaining( index ); return GetSubMeshContaining( index );
@ -1084,10 +1081,8 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
//============================================================================= //=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
throw(SALOME_Exception)
{ {
SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID ); SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
return aSubMesh; return aSubMesh;
} }
@ -1099,7 +1094,6 @@ throw(SALOME_Exception)
std::list<SMESH_subMesh*> std::list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{ {
std::list<SMESH_subMesh*> found; std::list<SMESH_subMesh*> found;
@ -1273,13 +1267,13 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
* Auto color functionality * Auto color functionality
*/ */
//============================================================================= //=============================================================================
void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception) void SMESH_Mesh::SetAutoColor(bool theAutoColor)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
_isAutoColor = theAutoColor; _isAutoColor = theAutoColor;
} }
bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception) bool SMESH_Mesh::GetAutoColor()
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _isAutoColor; return _isAutoColor;
@ -1432,7 +1426,6 @@ void SMESH_Mesh::ExportMED(const char * file,
bool theAddODOnVertices, bool theAddODOnVertices,
double theZTolerance, double theZTolerance,
bool theAllElemsToGroup) bool theAllElemsToGroup)
throw(SALOME_Exception)
{ {
MESSAGE("MED_VERSION:"<< theVersion); MESSAGE("MED_VERSION:"<< theVersion);
SMESH_TRY; SMESH_TRY;
@ -1503,7 +1496,6 @@ throw(SALOME_Exception)
void SMESH_Mesh::ExportSAUV(const char *file, void SMESH_Mesh::ExportSAUV(const char *file,
const char* theMeshName, const char* theMeshName,
bool theAutoGroups) bool theAutoGroups)
throw(SALOME_Exception)
{ {
std::string medfilename(file); std::string medfilename(file);
medfilename += ".med"; medfilename += ".med";
@ -1547,7 +1539,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
//================================================================================ //================================================================================
void SMESH_Mesh::ExportDAT(const char * file, void SMESH_Mesh::ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception) const SMESHDS_Mesh* meshPart)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
DriverDAT_W_SMDS_Mesh myWriter; DriverDAT_W_SMDS_Mesh myWriter;
@ -1564,7 +1556,7 @@ void SMESH_Mesh::ExportDAT(const char * file,
//================================================================================ //================================================================================
void SMESH_Mesh::ExportUNV(const char * file, void SMESH_Mesh::ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception) const SMESHDS_Mesh* meshPart)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
DriverUNV_W_SMDS_Mesh myWriter; DriverUNV_W_SMDS_Mesh myWriter;
@ -1599,7 +1591,7 @@ void SMESH_Mesh::ExportUNV(const char * file,
void SMESH_Mesh::ExportSTL(const char * file, void SMESH_Mesh::ExportSTL(const char * file,
const bool isascii, const bool isascii,
const char * name, const char * name,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception) const SMESHDS_Mesh* meshPart)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
DriverSTL_W_SMDS_Mesh myWriter; DriverSTL_W_SMDS_Mesh myWriter;
@ -1754,7 +1746,7 @@ double SMESH_Mesh::GetComputeProgress() const
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbNodes() const throw(SALOME_Exception) int SMESH_Mesh::NbNodes() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->NbNodes(); return _myMeshDS->NbNodes();
@ -1766,7 +1758,7 @@ int SMESH_Mesh::NbNodes() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::Nb0DElements() const throw(SALOME_Exception) int SMESH_Mesh::Nb0DElements() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().Nb0DElements(); return _myMeshDS->GetMeshInfo().Nb0DElements();
@ -1778,7 +1770,7 @@ int SMESH_Mesh::Nb0DElements() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbEdges(order); return _myMeshDS->GetMeshInfo().NbEdges(order);
@ -1790,7 +1782,7 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbFaces(order); return _myMeshDS->GetMeshInfo().NbFaces(order);
@ -1802,7 +1794,7 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriangles(order); return _myMeshDS->GetMeshInfo().NbTriangles(order);
@ -1814,7 +1806,7 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const throw(SALOME_Excep
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbBiQuadTriangles() const throw(SALOME_Exception) int SMESH_Mesh::NbBiQuadTriangles() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadTriangles(); return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
@ -1826,7 +1818,7 @@ int SMESH_Mesh::NbBiQuadTriangles() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadrangles(order); return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
@ -1838,7 +1830,7 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exc
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbBiQuadQuadrangles() const throw(SALOME_Exception) int SMESH_Mesh::NbBiQuadQuadrangles() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles(); return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
@ -1850,7 +1842,7 @@ int SMESH_Mesh::NbBiQuadQuadrangles() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolygons(order); return _myMeshDS->GetMeshInfo().NbPolygons(order);
@ -1862,7 +1854,7 @@ int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const throw(SALOME_Except
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbVolumes(order); return _myMeshDS->GetMeshInfo().NbVolumes(order);
@ -1874,7 +1866,7 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const throw(SALOME_Excepti
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTetras(order); return _myMeshDS->GetMeshInfo().NbTetras(order);
@ -1886,7 +1878,7 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const throw(SALOME_Exceptio
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexas(order); return _myMeshDS->GetMeshInfo().NbHexas(order);
@ -1898,7 +1890,7 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const throw(SALOME_Exception
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbTriQuadraticHexas() const throw(SALOME_Exception) int SMESH_Mesh::NbTriQuadraticHexas() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriQuadHexas(); return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
@ -1910,7 +1902,7 @@ int SMESH_Mesh::NbTriQuadraticHexas() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPyramids(order); return _myMeshDS->GetMeshInfo().NbPyramids(order);
@ -1922,19 +1914,19 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const throw(SALOME_Except
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const throw(SALOME_Exception) int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPrisms(order); return _myMeshDS->GetMeshInfo().NbPrisms(order);
} }
int SMESH_Mesh::NbQuadPrisms() const throw (SALOME_Exception) int SMESH_Mesh::NbQuadPrisms() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms(); return _myMeshDS->GetMeshInfo().NbQuadPrisms();
} }
int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception) int SMESH_Mesh::NbBiQuadPrisms() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadPrisms(); return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
@ -1947,7 +1939,7 @@ int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbHexagonalPrisms() const throw(SALOME_Exception) int SMESH_Mesh::NbHexagonalPrisms() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexPrisms(); return _myMeshDS->GetMeshInfo().NbHexPrisms();
@ -1959,7 +1951,7 @@ int SMESH_Mesh::NbHexagonalPrisms() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbPolyhedrons() const throw(SALOME_Exception) int SMESH_Mesh::NbPolyhedrons() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolyhedrons(); return _myMeshDS->GetMeshInfo().NbPolyhedrons();
@ -1971,7 +1963,7 @@ int SMESH_Mesh::NbPolyhedrons() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbBalls() const throw(SALOME_Exception) int SMESH_Mesh::NbBalls() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBalls(); return _myMeshDS->GetMeshInfo().NbBalls();
@ -1983,7 +1975,7 @@ int SMESH_Mesh::NbBalls() const throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
int SMESH_Mesh::NbSubMesh() const throw(SALOME_Exception) int SMESH_Mesh::NbSubMesh() const
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
return _myMeshDS->NbSubMesh(); return _myMeshDS->NbSubMesh();
@ -2062,7 +2054,7 @@ SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
*/ */
//================================================================================ //================================================================================
SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception) SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS)
{ {
if ( !groupDS ) if ( !groupDS )
throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase")); throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase"));
@ -2414,18 +2406,19 @@ void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape)
bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) const bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) const
{ {
if ( !_mySubMeshOrder.size() || theListToSort.size() < 2) if ( _mySubMeshOrder.empty() || theListToSort.size() < 2 )
return true; return true;
bool res = false;
std::vector<SMESH_subMesh*> onlyOrderedList, smVec;
// collect all ordered submeshes in one list as pointers // collect all ordered sub-meshes in smVec as pointers
// and get their positions within theListToSort // and get their positions within theListToSort
std::vector<SMESH_subMesh*> smVec;
typedef std::vector<SMESH_subMesh*>::iterator TPosInList; typedef std::vector<SMESH_subMesh*>::iterator TPosInList;
std::map< int, TPosInList > sortedPos; std::map< size_t, size_t > sortedPos; // index in theListToSort to order
TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end(); TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end();
TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin(); TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin();
bool needSort = false;
for( ; listIdsIt != _mySubMeshOrder.end(); listIdsIt++) for( ; listIdsIt != _mySubMeshOrder.end(); listIdsIt++)
{ {
const TListOfInt& listOfId = *listIdsIt; const TListOfInt& listOfId = *listIdsIt;
@ -2452,27 +2445,46 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) con
// find smVec items in theListToSort // find smVec items in theListToSort
for ( size_t i = 0; i < smVec.size(); ++i ) for ( size_t i = 0; i < smVec.size(); ++i )
{ {
TPosInList smPos = find( smBeg, smEnd, smVec[i] ); TPosInList smPos = find( smBeg, smEnd, smVec[i] ); // position in theListToSort
if ( smPos != smEnd ) { if ( smPos != smEnd )
sortedPos[ std::distance( smBeg, smPos )] = smPos; {
if ( sortedPos.size() > onlyOrderedList.size() ) size_t posInList = std::distance( smBeg, smPos );
onlyOrderedList.push_back( smVec[i] ); size_t order = sortedPos.size();
sortedPos.insert( std::make_pair( posInList, order ));
if ( posInList != order )
needSort = true;
} }
} }
} }
if (onlyOrderedList.size() < 2) if ( ! needSort )
return res; return false;
res = true;
std::vector<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin(); // set sm of sortedPos from theListToSort to front of orderedSM
std::vector<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end(); // and the rest of theListToSort to orderedSM end
// iterate on ordered sub-meshes and insert them in detected positions std::vector<SMESH_subMesh*> orderedSM;
std::map< int, TPosInList >::iterator i_pos = sortedPos.begin(); orderedSM.reserve( theListToSort.size() );
for ( ; onlyBIt != onlyEIt; ++onlyBIt, ++i_pos ) orderedSM.resize( sortedPos.size() );
*(i_pos->second) = *onlyBIt;
return res; size_t iPrev = 0;
sortedPos.insert( std::make_pair( theListToSort.size(), sortedPos.size() ));
for ( const auto & pos_order : sortedPos )
{
const size_t& posInList = pos_order.first;
const size_t& order = pos_order.second;
if ( order < sortedPos.size() - 1 )
orderedSM[ order ] = theListToSort[ posInList ];
if ( iPrev < posInList )
orderedSM.insert( orderedSM.end(),
theListToSort.begin() + iPrev,
theListToSort.begin() + posInList );
iPrev = posInList + 1;
}
theListToSort.swap( orderedSM );
return true;
} }
//================================================================================ //================================================================================

84
src/SMESH/SMESH_Mesh.hxx
View File

@ -132,16 +132,13 @@ class SMESH_EXPORT SMESH_Mesh
bool theMakeRequiredGroups = true ); bool theMakeRequiredGroups = true );
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0) AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
throw(SALOME_Exception);
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId) RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
throw(SALOME_Exception);
const std::list <const SMESHDS_Hypothesis * >& const std::list <const SMESHDS_Hypothesis * >&
GetHypothesisList(const TopoDS_Shape & aSubShape) const GetHypothesisList(const TopoDS_Shape & aSubShape) const;
throw(SALOME_Exception);
const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape, const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape,
const SMESH_HypoFilter& aFilter, const SMESH_HypoFilter& aFilter,
@ -167,9 +164,9 @@ class SMESH_EXPORT SMESH_Mesh
SMESH_Hypothesis * GetHypothesis(const int aHypID) const; SMESH_Hypothesis * GetHypothesis(const int aHypID) const;
const std::list<SMESHDS_Command*> & GetLog() throw(SALOME_Exception); const std::list<SMESHDS_Command*> & GetLog();
void ClearLog() throw(SALOME_Exception); void ClearLog();
int GetId() const { return _id; } int GetId() const { return _id; }
@ -183,19 +180,15 @@ class SMESH_EXPORT SMESH_Mesh
SMESH_Gen *GetGen() { return _gen; } SMESH_Gen *GetGen() { return _gen; }
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape) SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape);
throw(SALOME_Exception);
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
throw(SALOME_Exception);
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const;
throw(SALOME_Exception);
/*! /*!
* \brief Return submeshes of groups containing the given subshape * \brief Return submeshes of groups containing the given subshape
*/ */
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const;
throw(SALOME_Exception);
/*! /*!
* \brief Say all submeshes that theChangedHyp has been modified * \brief Say all submeshes that theChangedHyp has been modified
*/ */
@ -223,9 +216,9 @@ class SMESH_EXPORT SMESH_Mesh
*/ */
const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const; const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
void SetAutoColor(bool theAutoColor) throw(SALOME_Exception); void SetAutoColor(bool theAutoColor);
bool GetAutoColor() throw(SALOME_Exception); bool GetAutoColor();
/*! /*!
* \brief Set the flag meaning that the mesh has been edited "manually". * \brief Set the flag meaning that the mesh has been edited "manually".
@ -266,17 +259,16 @@ class SMESH_EXPORT SMESH_Mesh
bool theAutoDimension = false, bool theAutoDimension = false,
bool theAddODOnVertices = false, bool theAddODOnVertices = false,
double theZTolerance = -1., double theZTolerance = -1.,
bool theAllElemsToGroup = false) bool theAllElemsToGroup = false);
throw(SALOME_Exception);
void ExportDAT(const char * file, void ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception); const SMESHDS_Mesh* meshPart = 0);
void ExportUNV(const char * file, void ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception); const SMESHDS_Mesh* meshPart = 0);
void ExportSTL(const char * file, void ExportSTL(const char * file,
const bool isascii, const bool isascii,
const char * name = 0, const char * name = 0,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception); const SMESHDS_Mesh* meshPart = 0);
void ExportCGNS(const char * file, void ExportCGNS(const char * file,
const SMESHDS_Mesh* mesh, const SMESHDS_Mesh* mesh,
const char * meshName = 0, const char * meshName = 0,
@ -286,35 +278,35 @@ class SMESH_EXPORT SMESH_Mesh
bool withRequiredGroups = true ); bool withRequiredGroups = true );
void ExportSAUV(const char *file, void ExportSAUV(const char *file,
const char* theMeshName = NULL, const char* theMeshName = NULL,
bool theAutoGroups = true) throw(SALOME_Exception); bool theAutoGroups = true);
double GetComputeProgress() const; double GetComputeProgress() const;
int NbNodes() const throw(SALOME_Exception); int NbNodes() const;
int Nb0DElements() const throw(SALOME_Exception); int Nb0DElements() const;
int NbBalls() const throw(SALOME_Exception); int NbBalls() const;
int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbBiQuadQuadrangles() const throw(SALOME_Exception); int NbBiQuadQuadrangles() const;
int NbBiQuadTriangles() const throw(SALOME_Exception); int NbBiQuadTriangles() const;
int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadraticHexas() const throw(SALOME_Exception); int NbTriQuadraticHexas() const;
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception); int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadPrisms() const throw(SALOME_Exception); int NbQuadPrisms() const;
int NbBiQuadPrisms() const throw(SALOME_Exception); int NbBiQuadPrisms() const;
int NbHexagonalPrisms() const throw(SALOME_Exception); int NbHexagonalPrisms() const;
int NbPolyhedrons() const throw(SALOME_Exception); int NbPolyhedrons() const;
int NbSubMesh() const throw(SALOME_Exception); int NbSubMesh() const;
int NbGroup() const { return _mapGroup.size(); } int NbGroup() const { return _mapGroup.size(); }
@ -326,7 +318,7 @@ class SMESH_EXPORT SMESH_Mesh
const TopoDS_Shape& theShape = TopoDS_Shape(), const TopoDS_Shape& theShape = TopoDS_Shape(),
const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr()); const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr());
SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception); SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS);
typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr; typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
GroupIteratorPtr GetGroups() const; GroupIteratorPtr GetGroups() const;

20
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -3857,9 +3857,9 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
} }
else { else {
if ( isUPeriodic ) if ( isUPeriodic )
newUV.SetX( ElCLib::InPeriod( newUV.X(), u1, u2 )); newUV.SetX( ElCLib::InPeriod( newUV.X(), u1, u2 )); // todo: u may be used unitialized
if ( isVPeriodic ) if ( isVPeriodic )
newUV.SetY( ElCLib::InPeriod( newUV.Y(), v1, v2 )); newUV.SetY( ElCLib::InPeriod( newUV.Y(), v1, v2 )); // todo: v may be used unitialized
// check new UV // check new UV
// if ( posType != SMDS_TOP_3DSPACE ) // if ( posType != SMDS_TOP_3DSPACE )
// dist2 = pNode.SquareDistance( surface->Value( newUV.X(), newUV.Y() )); // dist2 = pNode.SquareDistance( surface->Value( newUV.X(), newUV.Y() ));
@ -5666,10 +5666,10 @@ makeNodesByNormal2D( SMESHDS_Mesh* mesh,
//======================================================================= //=======================================================================
int SMESH_MeshEditor::ExtrusParam:: int SMESH_MeshEditor::ExtrusParam::
makeNodesByNormal1D( SMESHDS_Mesh* mesh, makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* /*srcNode*/,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & /*newNodes*/,
const bool makeMediumNodes) const bool /*makeMediumNodes*/)
{ {
throw SALOME_Exception("Extrusion 1D by Normal not implemented"); throw SALOME_Exception("Extrusion 1D by Normal not implemented");
return 0; return 0;
@ -6070,6 +6070,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
if ( nbEdges > 0 ) if ( nbEdges > 0 )
break; break;
} }
// fall through
default: default:
{ {
for ( int di = -1; di <= 1; di += 2 ) for ( int di = -1; di <= 1; di += 2 )
@ -7460,6 +7461,7 @@ public:
//int& GroupID() const { return const_cast< int& >( myGroupID ); } //int& GroupID() const { return const_cast< int& >( myGroupID ); }
ComparableElement( const ComparableElement& theSource ) // move copy ComparableElement( const ComparableElement& theSource ) // move copy
: boost::container::flat_set< int >()
{ {
ComparableElement& src = const_cast< ComparableElement& >( theSource ); ComparableElement& src = const_cast< ComparableElement& >( theSource );
(int_set&) (*this ) = boost::move( src ); (int_set&) (*this ) = boost::move( src );
@ -9216,7 +9218,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm, int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr, SMDS_ElemIteratorPtr theItr,
const int theShapeID) const int /*theShapeID*/)
{ {
int nbElem = 0; int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS(); SMESHDS_Mesh* meshDS = GetMeshDS();
@ -10198,7 +10200,7 @@ namespace // automatically find theAffectedElems for DoubleNodes()
if ( SMESH_MeshAlgos::FaceNormal( _elems[1], norm )) if ( SMESH_MeshAlgos::FaceNormal( _elems[1], norm ))
avgNorm += norm; avgNorm += norm;
gp_XYZ bordDir( SMESH_NodeXYZ( _nodes[0] ) - SMESH_NodeXYZ( _nodes[1] )); gp_XYZ bordDir( SMESH_NodeXYZ( _nodes[0] ) - SMESH_NodeXYZ( _nodes[1] )); // todo: compiler complains about zero-size array
norm = bordDir ^ avgNorm; norm = bordDir ^ avgNorm;
} }
else else
@ -11045,7 +11047,7 @@ double SMESH_MeshEditor::OrientedAngle(const gp_Pnt& p0, const gp_Pnt& p1, const
try { try {
return n2.AngleWithRef(n1, vref); return n2.AngleWithRef(n1, vref);
} }
catch ( Standard_Failure ) { catch ( Standard_Failure& ) {
} }
return Max( v1.Magnitude(), v2.Magnitude() ); return Max( v1.Magnitude(), v2.Magnitude() );
} }

15
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -2421,7 +2421,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n11, const SMDS_MeshNode* n11,
const SMDS_MeshNode* n12, const SMDS_MeshNode* n12,
const int id, const int id,
bool force3d) bool /*force3d*/)
{ {
SMESHDS_Mesh * meshDS = GetMeshDS(); SMESHDS_Mesh * meshDS = GetMeshDS();
SMDS_MeshVolume* elem = 0; SMDS_MeshVolume* elem = 0;
@ -3769,7 +3769,7 @@ namespace { // Structures used by FixQuadraticElements()
/*! /*!
* \brief Dump QLink and QFace * \brief Dump QLink and QFace
*/ */
ostream& operator << (ostream& out, const QLink& l) ostream& operator << (ostream& out, const QLink& l) // todo: unused in release mode
{ {
out <<"QLink nodes: " out <<"QLink nodes: "
<< l.node1()->GetID() << " - " << l.node1()->GetID() << " - "
@ -3777,7 +3777,7 @@ namespace { // Structures used by FixQuadraticElements()
<< l.node2()->GetID() << endl; << l.node2()->GetID() << endl;
return out; return out;
} }
ostream& operator << (ostream& out, const QFace& f) ostream& operator << (ostream& out, const QFace& f) // todo: unused in release mode
{ {
out <<"QFace nodes: "/*<< &f << " "*/; out <<"QFace nodes: "/*<< &f << " "*/;
for ( TIDSortedNodeSet::const_iterator n = f.begin(); n != f.end(); ++n ) for ( TIDSortedNodeSet::const_iterator n = f.begin(); n != f.end(); ++n )
@ -3820,6 +3820,7 @@ namespace { // Structures used by FixQuadraticElements()
#ifdef _DEBUG_ #ifdef _DEBUG_
_face = face; _face = face;
#endif #endif
(void)face; // unused in release mode
} }
//================================================================================ //================================================================================
/*! /*!
@ -4130,7 +4131,7 @@ namespace { // Structures used by FixQuadraticElements()
*/ */
//================================================================================ //================================================================================
bool QFace::IsSpoiled(const QLink* bentLink ) const bool QFace::IsSpoiled(const QLink* bentLink ) const // todo: unused
{ {
// code is valid for convex faces only // code is valid for convex faces only
gp_XYZ gc(0,0,0); gp_XYZ gc(0,0,0);
@ -4613,7 +4614,7 @@ namespace { // Structures used by FixQuadraticElements()
if ( curvNorm * D2 > 0 ) if ( curvNorm * D2 > 0 )
continue; // convex edge continue; // convex edge
} }
catch ( Standard_Failure ) catch ( Standard_Failure& )
{ {
continue; continue;
} }
@ -4728,7 +4729,7 @@ namespace { // Structures used by FixQuadraticElements()
if ( concaveU || concaveV ) if ( concaveU || concaveV )
concaveFaces.push_back( face ); concaveFaces.push_back( face );
} }
catch ( Standard_Failure ) catch ( Standard_Failure& )
{ {
concaveFaces.push_back( face ); concaveFaces.push_back( face );
} }
@ -5260,7 +5261,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
try { try {
gp_Vec x = x01.Normalized() + x12.Normalized(); gp_Vec x = x01.Normalized() + x12.Normalized();
trsf.SetTransformation( gp_Ax3( gp::Origin(), link1->Normal(), x), gp_Ax3() ); trsf.SetTransformation( gp_Ax3( gp::Origin(), link1->Normal(), x), gp_Ax3() );
} catch ( Standard_Failure ) { } catch ( Standard_Failure& ) {
trsf.Invert(); trsf.Invert();
} }
move.Transform(trsf); move.Transform(trsf);

4
src/SMESH/SMESH_Pattern.cxx
View File

@ -177,7 +177,7 @@ int readLine (list <const char*> & theFields,
case '-': // real number case '-': // real number
case '+': case '+':
case '.': case '.':
isNumber = true; isNumber = true; // fall through
default: // data default: // data
isNumber = isNumber || ( *theLineBeg >= '0' && *theLineBeg <= '9' ); isNumber = isNumber || ( *theLineBeg >= '0' && *theLineBeg <= '9' );
if ( isNumber ) { if ( isNumber ) {
@ -4289,11 +4289,13 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3], elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5] ); break; nodes[4], nodes[5] ); break;
} // else do not break but create a polygon } // else do not break but create a polygon
// fall through
case 8: case 8:
if ( !onMeshElements ) {// create a quadratic face if ( !onMeshElements ) {// create a quadratic face
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3], elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7] ); break; nodes[4], nodes[5], nodes[6], nodes[7] ); break;
} // else do not break but create a polygon } // else do not break but create a polygon
// fall through
default: default:
elem = aMeshDS->AddPolygonalFace( nodes ); elem = aMeshDS->AddPolygonalFace( nodes );
} }

2
src/SMESH/SMESH_ProxyMesh.hxx
View File

@ -92,7 +92,7 @@ public:
protected: // methods of SMDS_ElementHolder; remove elements before mesh compacting or clearing protected: // methods of SMDS_ElementHolder; remove elements before mesh compacting or clearing
virtual SMDS_ElemIteratorPtr getElements() { Clear(); return GetElements(); } virtual SMDS_ElemIteratorPtr getElements() { Clear(); return GetElements(); }
virtual void tmpClear() {} virtual void tmpClear() {}
virtual void add( const SMDS_MeshElement* element ) {} virtual void add( const SMDS_MeshElement* /*element*/ ) {}
virtual void compact() {} virtual void compact() {}
virtual void clear() { Clear(); } virtual void clear() { Clear(); }
}; };

5
src/SMESH/SMESH_subMesh.cxx
View File

@ -1445,6 +1445,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes(); loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED ); ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break; //break;
// fall through
case CHECK_COMPUTE_STATE: case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() ) if ( IsMeshComputed() )
_computeState = COMPUTE_OK; _computeState = COMPUTE_OK;
@ -1496,6 +1497,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
} }
break; break;
} }
// fall through
case COMPUTE: case COMPUTE:
case COMPUTE_SUBMESH: case COMPUTE_SUBMESH:
{ {
@ -1763,6 +1765,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes(); loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED ); ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break; //break;
// fall through
case CHECK_COMPUTE_STATE: case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() ) if ( IsMeshComputed() )
_computeState = COMPUTE_OK; _computeState = COMPUTE_OK;
@ -2149,7 +2152,7 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
// meshed at once along with _subShape // meshed at once along with _subShape
//======================================================================= //=======================================================================
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed, bool & theSubComputed,
bool & theSubFailed, bool & theSubFailed,

4
src/SMESH/SMESH_subMeshEventListener.hxx
View File

@ -55,8 +55,8 @@ class SMESH_EXPORT SMESH_subMeshEventListener
virtual ~SMESH_subMeshEventListener() {} virtual ~SMESH_subMeshEventListener() {}
bool IsDeletable() const { return myIsDeletable; } bool IsDeletable() const { return myIsDeletable; }
const char* GetName() const { return myName; } const char* GetName() const { return myName; }
virtual void BeforeDelete(SMESH_subMesh* subMesh, virtual void BeforeDelete(SMESH_subMesh* /*subMesh*/,
SMESH_subMeshEventListenerData* data) SMESH_subMeshEventListenerData* /*data*/)
{} {}
/*! /*!
* \brief Do something on a certain event * \brief Do something on a certain event

6
src/SMESHClient/SMESH_Client.cxx
View File

@ -745,9 +745,9 @@ namespace
//======================================================================= //=======================================================================
//function : ChangePolyhedronNodes //function : ChangePolyhedronNodes
//======================================================================= //=======================================================================
inline void ChangePolyhedronNodes (SMDS_Mesh* theMesh, inline void ChangePolyhedronNodes (SMDS_Mesh* /*theMesh*/,
SMESH::log_array_var& theSeq, SMESH::log_array_var& /*theSeq*/,
CORBA::Long theId) CORBA::Long /*theId*/)
{ {
// const SMESH::long_array& anIndexes = theSeq[theId].indexes; // const SMESH::long_array& anIndexes = theSeq[theId].indexes;
// CORBA::Long iind = 0, aNbElems = theSeq[theId].number; // CORBA::Long iind = 0, aNbElems = theSeq[theId].number;

4
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -273,7 +273,7 @@ bool SMESHDS_Mesh
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, const int /*deltaID*/)
{ {
// TODO not possible yet to have node numbers not starting to O and continuous. // TODO not possible yet to have node numbers not starting to O and continuous.
if ( !this->IsCompacted() ) if ( !this->IsCompacted() )
@ -838,7 +838,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
static void removeFromContainers (SMESHDS_Mesh* theMesh, static void removeFromContainers (SMESHDS_Mesh* /*theMesh*/,
std::set<SMESHDS_GroupBase*>& theGroups, std::set<SMESHDS_GroupBase*>& theGroups,
std::vector<const SMDS_MeshElement*>& theElems) std::vector<const SMDS_MeshElement*>& theElems)
{ {

12
src/SMESHGUI/SMESHGUI.cxx
View File

@ -2760,7 +2760,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
OCC_CATCH_SIGNALS; OCC_CATCH_SIGNALS;
SMESH::UpdateView(); SMESH::UpdateView();
} }
catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups) catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
SMESH::OnVisuException(); SMESH::OnVisuException();
} }
catch (...) { // PAL16774 (Crash after display of many groups) catch (...) { // PAL16774 (Crash after display of many groups)
@ -2865,7 +2865,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpCreateSubMesh: case SMESHOp::OpCreateSubMesh:
if ( warnOnGeomModif() ) if ( warnOnGeomModif() )
break; // action forbiden as geometry modified break; // action forbiden as geometry modified
// fall through
case SMESHOp::OpCreateMesh: case SMESHOp::OpCreateMesh:
case SMESHOp::OpCompute: case SMESHOp::OpCompute:
case SMESHOp::OpComputeSubMesh: case SMESHOp::OpComputeSubMesh:
@ -3977,7 +3977,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return false; return false;
} }
@ -3987,7 +3987,7 @@ bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return true; return true;
} }
@ -3997,7 +3997,7 @@ bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return true; return true;
} }
@ -5332,7 +5332,7 @@ void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
void SMESHGUI::ProcessEvents( vtkObject* theObject, void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent, unsigned long theEvent,
void* theClientData, void* theClientData,
void* theCallData ) void* /*theCallData*/ )
{ {
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) { if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) { if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {

6
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -1274,7 +1274,7 @@ void SMESHGUI_AddQuadraticElementDlg::enterEvent (QEvent*)
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_AddQuadraticElementDlg::onReverse (int state) void SMESHGUI_AddQuadraticElementDlg::onReverse (int /*state*/)
{ {
mySimulation->SetVisibility(false); mySimulation->SetVisibility(false);
displaySimulation(); displaySimulation();
@ -1449,7 +1449,7 @@ void SMESHGUI_AddQuadraticElementDlg::UpdateTable( bool theConersValidity )
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCol ) void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int /*theRow*/, int /*theCol*/ )
{ {
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
displaySimulation(); displaySimulation();
@ -1461,7 +1461,7 @@ void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCo
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int theRow, int theCol) void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int /*theRow*/, int /*theCol*/)
{ {
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
displaySimulation(); displaySimulation();

4
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

@ -81,7 +81,7 @@ namespace SMESH
public: public:
static OrientedPlane *New(); static OrientedPlane *New();
static OrientedPlane *New(SVTK_ViewWindow* theViewWindow); static OrientedPlane *New(SVTK_ViewWindow* theViewWindow);
vtkTypeMacro (OrientedPlane, vtkPlane); vtkTypeMacro (OrientedPlane, vtkPlane)
QPointer<SVTK_ViewWindow> myViewWindow; QPointer<SVTK_ViewWindow> myViewWindow;
SMESH::Orientation myRelativeOrientation; SMESH::Orientation myRelativeOrientation;
@ -135,7 +135,7 @@ namespace SMESH
typedef std::vector<TPlane> TPlaneVector; typedef std::vector<TPlane> TPlaneVector;
typedef std::vector<TPlaneData> TPlaneDataVector; typedef std::vector<TPlaneData> TPlaneDataVector;
}; }
//================================================================================= //=================================================================================
// class : SMESHGUI_ClippingDlg // class : SMESHGUI_ClippingDlg

2
src/SMESHGUI/SMESHGUI_FieldSelectorWdg.cxx
View File

@ -214,7 +214,7 @@ bool SMESHGUI_FieldSelectorWdg::GetSelectedFields()
/*! /*!
* \brief SLOT called when a tree item is checked * \brief SLOT called when a tree item is checked
*/ */
void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int column) void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int /*column*/)
{ {
myTree->blockSignals( true ); myTree->blockSignals( true );
if ( !item->parent() ) // mesh item if ( !item->parent() ) // mesh item

2
src/SMESHGUI/SMESHGUI_Filter.h
View File

@ -55,7 +55,7 @@ namespace SMESH
FirstEntityTypeFilter = FirstGeometryTypeFilter + SMDSGeom_NONE, FirstEntityTypeFilter = FirstGeometryTypeFilter + SMDSGeom_NONE,
LastFilter = FirstEntityTypeFilter + SMDSEntity_Last LastFilter = FirstEntityTypeFilter + SMDSEntity_Last
}; };
}; }
/* /*
Class : SMESHGUI_Filter Class : SMESHGUI_Filter

8
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
View File

@ -697,7 +697,7 @@ void SMESHGUI_FilterTable::ComboDelegate::setModelData( QWidget* editor,
void SMESHGUI_FilterTable::ComboDelegate::updateEditorGeometry( QWidget* editor, void SMESHGUI_FilterTable::ComboDelegate::updateEditorGeometry( QWidget* editor,
const QStyleOptionViewItem& option, const QStyleOptionViewItem& option,
const QModelIndex& index ) const const QModelIndex& /*index*/ ) const
{ {
editor->setGeometry( option.rect ); editor->setGeometry( option.rect );
} }
@ -1732,6 +1732,7 @@ static QList<int> entityTypes( const int theType )
{ {
case SMESH::NODE: case SMESH::NODE:
typeIds.append( SMDSEntity_Node ); typeIds.append( SMDSEntity_Node );
break;
case SMESH::EDGE: case SMESH::EDGE:
typeIds.append( SMDSEntity_Edge ); typeIds.append( SMDSEntity_Edge );
typeIds.append( SMDSEntity_Quad_Edge ); typeIds.append( SMDSEntity_Quad_Edge );
@ -1776,7 +1777,7 @@ static QList<int> entityTypes( const int theType )
// Purpose : Provides reaction on change of criterion // Purpose : Provides reaction on change of criterion
//======================================================================= //=======================================================================
void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType) void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int /*col*/, const int entityType)
{ {
int aType = entityType == -1 ? GetType() : entityType; int aType = entityType == -1 ? GetType() : entityType;
Table* aTable = myTables[ aType ]; Table* aTable = myTables[ aType ];
@ -2377,7 +2378,7 @@ const QMap<int, QString>& SMESHGUI_FilterTable::getCompare() const
// Purpose : Create table // Purpose : Create table
//======================================================================= //=======================================================================
SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent, SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent,
const int theType) const int /*theType*/)
{ {
// create table // create table
Table* aTable= new Table(0, 6, theParent); Table* aTable= new Table(0, 6, theParent);
@ -3816,6 +3817,7 @@ void SMESHGUI_FilterDlg::onSelectionDone()
myTable->SetThreshold(aRow, SMESH::toQStr( grp->GetName() )); myTable->SetThreshold(aRow, SMESH::toQStr( grp->GetName() ));
myTable->SetID (aRow, anIO->getEntry() ); myTable->SetID (aRow, anIO->getEntry() );
} }
break;
} }
default: // get a GEOM object default: // get a GEOM object
{ {

3
src/SMESHGUI/SMESHGUI_FilterLibraryDlg.cxx
View File

@ -1152,7 +1152,7 @@ const SMESHGUI_FilterTable* SMESHGUI_FilterLibraryDlg::GetTable() const
// name : SMESHGUI_FilterLibraryDlg::onEntityTypeChanged // name : SMESHGUI_FilterLibraryDlg::onEntityTypeChanged
// Purpose : SLOT. Called when entiyt type changed // Purpose : SLOT. Called when entiyt type changed
//======================================================================= //=======================================================================
void SMESHGUI_FilterLibraryDlg::onEntityTypeChanged(const int theType) void SMESHGUI_FilterLibraryDlg::onEntityTypeChanged(const int /*theType*/)
{ {
if (myLibrary->_is_nil()) if (myLibrary->_is_nil())
return; return;
@ -1244,6 +1244,7 @@ void SMESHGUI_FilterLibraryDlg::onSelectionDone()
case SMESH::FT_BelongToMeshGroup: // get a group name and IOR case SMESH::FT_BelongToMeshGroup: // get a group name and IOR
{ {
myTable->SetThreshold(aRow, anIO->getName() ); myTable->SetThreshold(aRow, anIO->getName() );
break;
} }
default: // get a GEOM object default: // get a GEOM object
{ {

2
src/SMESHGUI/SMESHGUI_GEOMGenUtils.cxx
View File

@ -46,7 +46,7 @@ namespace SMESH
{ {
GEOM::GEOM_Gen_var GetGEOMGen( GEOM::GEOM_Object_ptr go ) GEOM::GEOM_Gen_var GetGEOMGen( GEOM::GEOM_Object_ptr go )
{ {
GEOM::GEOM_Gen_ptr gen; GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go )) if ( !CORBA::is_nil( go ))
gen = go->GetGen(); gen = go->GetGen();
return gen; return gen;

4
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

@ -767,7 +767,7 @@ void SMESHGUI_GroupDlg::updateButtons()
// function : onNameChanged() // function : onNameChanged()
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_GroupDlg::onNameChanged (const QString& text) void SMESHGUI_GroupDlg::onNameChanged (const QString& /*text*/)
{ {
myOldName = myName->text(); myOldName = myName->text();
updateButtons(); updateButtons();
@ -814,7 +814,7 @@ void SMESHGUI_GroupDlg::onGrpTypeChanged (int id)
// function : onColorChanged() // function : onColorChanged()
// purpose : Color button management // purpose : Color button management
//================================================================================= //=================================================================================
void SMESHGUI_GroupDlg::onColorChanged(QColor theColor) void SMESHGUI_GroupDlg::onColorChanged(QColor /*theColor*/)
{ {
updateButtons(); updateButtons();
} }

2
src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
View File

@ -592,7 +592,7 @@ namespace SMESH
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString& aHypType, SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString& aHypType,
const QString& aHypName, const QString& aHypName,
const bool isAlgo) const bool /*isAlgo*/)
{ {
if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() << if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() <<
" with name " << aHypName.toLatin1().data()); " with name " << aHypName.toLatin1().data());

2
src/SMESHGUI/SMESHGUI_Make2DFrom3DOp.cxx
View File

@ -316,7 +316,7 @@ void SMESHGUI_Make2DFrom3DOp::selectionDone()
} }
} }
SUIT_SelectionFilter* SMESHGUI_Make2DFrom3DOp::createFilter( const int theId ) const SUIT_SelectionFilter* SMESHGUI_Make2DFrom3DOp::createFilter( const int /*theId*/ ) const
{ {
SMESHGUI_Make2DFrom3DOp* me = (SMESHGUI_Make2DFrom3DOp*) this; SMESHGUI_Make2DFrom3DOp* me = (SMESHGUI_Make2DFrom3DOp*) this;

10
src/SMESHGUI/SMESHGUI_Measurements.h
View File

@ -46,7 +46,7 @@ class SMESHGUI_MeshEditPreview;
class SMESHGUI_EXPORT SMESHGUI_MinDistance : public QWidget class SMESHGUI_EXPORT SMESHGUI_MinDistance : public QWidget
{ {
Q_OBJECT; Q_OBJECT
enum { NoTgt, FirstTgt, SecondTgt }; enum { NoTgt, FirstTgt, SecondTgt };
enum { OriginTgt, NodeTgt, ElementTgt, ObjectTgt }; enum { OriginTgt, NodeTgt, ElementTgt, ObjectTgt };
@ -95,7 +95,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_BoundingBox : public QWidget class SMESHGUI_EXPORT SMESHGUI_BoundingBox : public QWidget
{ {
Q_OBJECT; Q_OBJECT
enum { ObjectsSrc, NodesSrc, ElementsSrc }; enum { ObjectsSrc, NodesSrc, ElementsSrc };
@ -141,7 +141,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_BasicProperties : public QWidget class SMESHGUI_EXPORT SMESHGUI_BasicProperties : public QWidget
{ {
Q_OBJECT; Q_OBJECT
public: public:
//! Property type //! Property type
@ -172,7 +172,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_Angle : public QWidget class SMESHGUI_EXPORT SMESHGUI_Angle : public QWidget
{ {
Q_OBJECT; Q_OBJECT
public: public:
@ -206,7 +206,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_MeasureDlg : public QDialog class SMESHGUI_EXPORT SMESHGUI_MeasureDlg : public QDialog
{ {
Q_OBJECT; Q_OBJECT
enum { NodeMode, ElemMode }; enum { NodeMode, ElemMode };

2
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
View File

@ -1621,7 +1621,7 @@ void SMESHGUI_MergeDlg::onSelectKeep()
// IDs to groups or vice versa // IDs to groups or vice versa
//======================================================================= //=======================================================================
void SMESHGUI_MergeDlg::onKeepSourceChanged(int isGroup) void SMESHGUI_MergeDlg::onKeepSourceChanged(int /*isGroup*/)
{ {
KeepList->clear(); KeepList->clear();
SelectKeepButton->click(); SelectKeepButton->click();

2
src/SMESHGUI/SMESHGUI_MergeDlg.h
View File

@ -72,7 +72,7 @@ namespace SMESH
//================================================================================= //=================================================================================
class SMESHGUI_EXPORT SMESHGUI_MergeDlg : public QDialog class SMESHGUI_EXPORT SMESHGUI_MergeDlg : public QDialog
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_MergeDlg( SMESHGUI*, int ); SMESHGUI_MergeDlg( SMESHGUI*, int );

10
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -1804,7 +1804,7 @@ void SMESHGUI_ElemInfo::writeInfo( InfoWriter* writer, const QList<uint>& ids )
writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) ); writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
} }
int size = group.size(); int size = group.size();
if ( size != -1 ); if ( size != -1 )
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size ); writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color(); QColor color = group.color();
if ( color.isValid() ) if ( color.isValid() )
@ -1935,7 +1935,7 @@ void SMESHGUI_ElemInfo::writeInfo( InfoWriter* writer, const QList<uint>& ids )
writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) ); writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
} }
int size = group.size(); int size = group.size();
if ( size != -1 ); if ( size != -1 )
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size ); writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color(); QColor color = group.color();
if ( color.isValid() ) if ( color.isValid() )
@ -2175,8 +2175,8 @@ void SMESHGUI_TreeElemInfo::information( const QList<uint>& ids )
\param nbNodes number of unique nodes in element \param nbNodes number of unique nodes in element
\param parentItem parent item of tree \param parentItem parent item of tree
*/ */
void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index, void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* /*node*/, int /*index*/,
int nbNodes, QTreeWidgetItem* parentItem ) int /*nbNodes*/, QTreeWidgetItem* /*parentItem*/ )
{ {
// int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 ); // int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
// // node number and ID // // node number and ID
@ -2284,7 +2284,7 @@ void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
} }
} }
void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn ) void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int /*theColumn*/ )
{ {
if ( theItem ) { if ( theItem ) {
int type = theItem->data( 1, TypeRole ).toInt(); int type = theItem->data( 1, TypeRole ).toInt();

18
src/SMESHGUI/SMESHGUI_MeshInfo.h
View File

@ -71,7 +71,7 @@ public:
class SMESHGUI_EXPORT SMESHGUI_BaseInfo : public SMESHGUI_Info class SMESHGUI_EXPORT SMESHGUI_BaseInfo : public SMESHGUI_Info
{ {
Q_OBJECT; Q_OBJECT
enum enum
{ {
@ -158,7 +158,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_ElemInfo : public SMESHGUI_Info class SMESHGUI_EXPORT SMESHGUI_ElemInfo : public SMESHGUI_Info
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_ElemInfo( QWidget* = 0 ); SMESHGUI_ElemInfo( QWidget* = 0 );
@ -205,7 +205,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_SimpleElemInfo : public SMESHGUI_ElemInfo class SMESHGUI_EXPORT SMESHGUI_SimpleElemInfo : public SMESHGUI_ElemInfo
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_SimpleElemInfo( QWidget* = 0 ); SMESHGUI_SimpleElemInfo( QWidget* = 0 );
@ -223,7 +223,7 @@ private slots:
class SMESHGUI_EXPORT SMESHGUI_TreeElemInfo : public SMESHGUI_ElemInfo class SMESHGUI_EXPORT SMESHGUI_TreeElemInfo : public SMESHGUI_ElemInfo
{ {
Q_OBJECT; Q_OBJECT
class ItemDelegate; class ItemDelegate;
class ItemCreator; class ItemCreator;
@ -251,7 +251,7 @@ private:
class InfoComputor: public QObject class InfoComputor: public QObject
{ {
Q_OBJECT; Q_OBJECT
public: public:
enum { GrpSize, GrpNbNodes }; enum { GrpSize, GrpNbNodes };
@ -271,7 +271,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_AddInfo : public SMESHGUI_Info class SMESHGUI_EXPORT SMESHGUI_AddInfo : public SMESHGUI_Info
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_AddInfo( QWidget* = 0 ); SMESHGUI_AddInfo( QWidget* = 0 );
@ -307,7 +307,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_CtrlInfo : public SMESHGUI_Info class SMESHGUI_EXPORT SMESHGUI_CtrlInfo : public SMESHGUI_Info
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_CtrlInfo( QWidget* = 0 ); SMESHGUI_CtrlInfo( QWidget* = 0 );
@ -354,7 +354,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_MeshInfoDlg : public QDialog class SMESHGUI_EXPORT SMESHGUI_MeshInfoDlg : public QDialog
{ {
Q_OBJECT; Q_OBJECT
enum { NodeMode, ElemMode, GroupMode }; enum { NodeMode, ElemMode, GroupMode };
@ -409,7 +409,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_CtrlInfoDlg : public QDialog class SMESHGUI_EXPORT SMESHGUI_CtrlInfoDlg : public QDialog
{ {
Q_OBJECT; Q_OBJECT
public: public:
SMESHGUI_CtrlInfoDlg( QWidget* = 0 ); SMESHGUI_CtrlInfoDlg( QWidget* = 0 );

6
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -882,7 +882,7 @@ void SMESHGUI_MeshOp::availableHyps( const int theDim,
THypDataList& theDataList, THypDataList& theDataList,
HypothesisData* thePrevAlgoData, HypothesisData* thePrevAlgoData,
HypothesisData* theNextAlgoData, HypothesisData* theNextAlgoData,
const QString& theMeshType) const QString& /*theMeshType*/)
{ {
theDataList.clear(); theDataList.clear();
theHyps.clear(); theHyps.clear();
@ -1434,7 +1434,7 @@ void SMESHGUI_MeshOp::onEditHyp( const int theHypType, const int theIndex )
* 1 = accepted * 1 = accepted
*/ */
//================================================================================ //================================================================================
void SMESHGUI_MeshOp::onHypoEdited( int result ) void SMESHGUI_MeshOp::onHypoEdited( int /*result*/ )
{ {
int obj = myDlg->getActiveObject(); int obj = myDlg->getActiveObject();
onActivateObject( obj ); // Issue 0020170. Restore filters onActivateObject( obj ); // Issue 0020170. Restore filters
@ -2975,7 +2975,7 @@ void SMESHGUI_MeshOp::updateHypoSets()
* \param theIndex - Index of current type of mesh * \param theIndex - Index of current type of mesh
*/ */
//================================================================================ //================================================================================
void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex ) void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int /*theTabIndex*/, const int /*theIndex*/ )
{ {
setFilteredAlgoData(); setFilteredAlgoData();
} }

1
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -369,7 +369,6 @@ SMESH::NumericalFunctor_ptr SMESHGUI_MultiEditDlg::getNumericalFunctor()
aNF = aFilterMgr->CreateMultiConnection2D(); aNF = aFilterMgr->CreateMultiConnection2D();
else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS")) else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS"))
aNF = aFilterMgr->CreateMaxElementLength2D(); aNF = aFilterMgr->CreateMaxElementLength2D();
else;
return aNF._retn(); return aNF._retn();
} }

2
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -395,7 +395,7 @@ void SMESHGUI_NodesDlg::Init()
// function : ValueChangedInSpinBox() // function : ValueChangedInSpinBox()
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double newValue ) void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double /*newValue*/ )
{ {
if ( !myMesh->_is_nil() ) { if ( !myMesh->_is_nil() ) {
double vx = SpinBox_X->GetValue(); double vx = SpinBox_X->GetValue();

2
src/SMESHGUI/SMESHGUI_PreVisualObj.cxx
View File

@ -35,7 +35,7 @@ SMDS_Mesh* SMESHGUI_PreVisualObj::GetMesh() const
return myMesh; return myMesh;
} }
bool SMESHGUI_PreVisualObj::Update( int theIsClear = true ) bool SMESHGUI_PreVisualObj::Update( int /*theIsClear*/)
{ {
return false; return false;
} }

4
src/SMESHGUI/SMESHGUI_PreviewDlg.cxx
View File

@ -101,7 +101,7 @@ void SMESHGUI_PreviewDlg::toDisplaySimulation() {
// function : onDisplaySimulation // function : onDisplaySimulation
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_PreviewDlg::onDisplaySimulation(bool toDisplayPreview) { void SMESHGUI_PreviewDlg::onDisplaySimulation(bool /*toDisplayPreview*/) {
//Empty implementation here //Empty implementation here
} }
@ -212,7 +212,7 @@ void SMESHGUI_MultiPreviewDlg::toDisplaySimulation()
// function : onDisplaySimulation // function : onDisplaySimulation
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_MultiPreviewDlg::onDisplaySimulation( bool toDisplayPreview ) void SMESHGUI_MultiPreviewDlg::onDisplaySimulation( bool /*toDisplayPreview*/ )
{ {
//Empty implementation here //Empty implementation here
} }

2
src/SMESHGUI/SMESHGUI_RenumberingDlg.cxx
View File

@ -385,7 +385,7 @@ void SMESHGUI_RenumberingDlg::ActivateThisDialog()
// function : enterEvent() // function : enterEvent()
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_RenumberingDlg::enterEvent(QEvent* e) void SMESHGUI_RenumberingDlg::enterEvent(QEvent* /*e*/)
{ {
if (GroupConstructors->isEnabled()) if (GroupConstructors->isEnabled())
return; return;

2
src/SMESHGUI/SMESHGUI_RevolutionDlg.cxx
View File

@ -573,7 +573,7 @@ void SMESHGUI_RevolutionDlg::ClickOnHelp()
// function : onAngleTextChange() // function : onAngleTextChange()
// purpose : // purpose :
//======================================================================= //=======================================================================
void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& theNewText) void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& /*theNewText*/)
{ {
bool isNumber; bool isNumber;
SpinBox_Angle->text().toDouble( &isNumber ); SpinBox_Angle->text().toDouble( &isNumber );

2
src/SMESHGUI/SMESHGUI_SelectionOp.cxx
View File

@ -195,7 +195,7 @@ void SMESHGUI_SelectionOp::onActivateObject( int id )
// name : onDeactivateObject // name : onDeactivateObject
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_SelectionOp::onDeactivateObject( int id ) void SMESHGUI_SelectionOp::onDeactivateObject( int /*id*/ )
{ {
removeCustomFilters(); removeCustomFilters();
} }

6
src/SMESHGUI/SMESHGUI_SewingDlg.cxx
View File

@ -1243,16 +1243,16 @@ void SMESHGUI_SewingDlg::onMoveBorderEnd(int button)
{ {
aPRT.node1 = ( aPRT.node1 + size + dn ) % size; aPRT.node1 = ( aPRT.node1 + size + dn ) % size;
aPRT.node2 = ( aPRT.node2 + size + dn ) % size; aPRT.node2 = ( aPRT.node2 + size + dn ) % size;
break;
} }
break;
case MOVE_LEFT_2: case MOVE_LEFT_2:
case MOVE_RIGHT_2: case MOVE_RIGHT_2:
if (( isClosed ) || if (( isClosed ) ||
( 0 <= aPRT.nodeLast+dn && aPRT.nodeLast+dn < size )) ( 0 <= aPRT.nodeLast+dn && aPRT.nodeLast+dn < size ))
{ {
aPRT.nodeLast = ( aPRT.nodeLast + size + dn ) % size; aPRT.nodeLast = ( aPRT.nodeLast + size + dn ) % size;
break;
} }
break;
default: default:
return; // impossible to move return; // impossible to move
} }
@ -1798,7 +1798,7 @@ void SMESHGUI_SewingDlg::ActivateThisDialog()
// function : enterEvent() // function : enterEvent()
// purpose : // purpose :
//================================================================================= //=================================================================================
void SMESHGUI_SewingDlg::enterEvent (QEvent* e) void SMESHGUI_SewingDlg::enterEvent (QEvent* /*e*/)
{ {
if (!ConstructorsBox->isEnabled()) { if (!ConstructorsBox->isEnabled()) {
SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ); SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );

2
src/SMESHGUI/SMESHGUI_ShapeByMeshDlg.cxx
View File

@ -469,7 +469,7 @@ void SMESHGUI_ShapeByMeshOp::activateSelection()
//purpose : SLOT. Called when element type changed. //purpose : SLOT. Called when element type changed.
//======================================================================= //=======================================================================
void SMESHGUI_ShapeByMeshOp::onTypeChanged (int theType) void SMESHGUI_ShapeByMeshOp::onTypeChanged (int /*theType*/)
{ {
setElementID(""); setElementID("");
activateSelection(); activateSelection();

Some files were not shown because too many files have changed in this diff Show More