ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-25 17:00:34 +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)
MESSAGE(STATUS "Build MEFISTO2D mesher using Fortran to C generator")
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(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;
}
@ -2072,7 +2072,7 @@ SMDSAbs_ElementType MultiConnection::GetType() const
*/
//================================================================================
double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
double MultiConnection2D::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
@ -4263,7 +4263,7 @@ private:
bool isOutOfFace (const gp_Pnt& p);
bool isOutOfEdge (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);
TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid );

6
src/Controls/SMESH_ControlsDef.hxx
View File

@ -129,7 +129,7 @@ namespace SMESH{
NumericalFunctor();
virtual void SetMesh( const SMDS_Mesh* theMesh );
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,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
@ -1214,8 +1214,8 @@ namespace SMESH{
protected:
PredicatePtr myPredicate;
};
};
};
}
}
#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?
int len = 0;
if (s[i] >> 5 == 0b110 ) len = 1;
else if (s[i] >> 4 == 0b1110 ) len = 2;
else if (s[i] >> 3 == 0b11110) len = 3;
if (s[i] >> 5 == 0b110 ) len = 1; // todo: binary constants are a GCC extension
else if (s[i] >> 4 == 0b1110 ) len = 2; // todo: binary constants are a GCC extension
else if (s[i] >> 3 == 0b11110) len = 3; // todo: binary constants are a GCC extension
else
invalid = true;
// check the bytes
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 )
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 std::string GetMeshName() const;
virtual void SetOption(const std::string& optionName,
const std::string& optionValue) {}
virtual void SetOption(const std::string& /*optionName*/,
const std::string& /*optionValue*/) {}
virtual Status Perform() = 0;

10
src/DriverCGNS/DriverCGNS_Read.cxx
View File

@ -134,12 +134,12 @@ namespace
ids[2] = ids[0] + _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[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[1] = ids[0] + 1;
@ -187,7 +187,7 @@ namespace
}
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 )
{
_cur[i] += _dir[i];
@ -207,7 +207,7 @@ namespace
size *= _dir[i]*(_end[i]-_beg[i]);
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 ); }
};
@ -297,7 +297,7 @@ namespace
}
// 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 );
gp_XYZ begin1 = rangeIt1.Begin(), begin2 = rangeIt2.Begin(), index1, index2;
if ( &zone2 == this )

10
src/DriverGMF/libmesh5.c
View File

@ -78,7 +78,7 @@ typedef struct
static int GmfIniFlg=0;
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] =
{ {"Reserved", "", "", ""},
{"MeshVersionFormatted", "", "", "i"},
@ -875,7 +875,7 @@ void GmfSetLin(int MshIdx, int KwdCod, ...)
{
for(i=0;i<kwd->SolSiz;i++)
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') {
nb_repeat = va_arg(VarArg, int);
fprintf(msh->hdl, "%d ", nb_repeat);
@ -936,7 +936,7 @@ void GmfSetLin(int MshIdx, int KwdCod, ...)
if(msh->typ & Asc)
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
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,
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++)
if(!strcmp(str, GmfKwdFmt[ KwdCod ][0]))
{
@ -1191,7 +1191,7 @@ static void ExpFmt(GmfMshSct *msh, int KwdCod)
i = kwd->SolSiz = kwd->NmbWrd = 0;
while(i < strlen(InpFmt))
while(i < (int)strlen(InpFmt))
{
chr = InpFmt[ i++ ];

12
src/DriverGMF/libmesh5.h
View File

@ -18,7 +18,15 @@
/* 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 GmfMaxTyp 1000
@ -33,7 +41,7 @@
#define GmfFloat 1
#define GmfDouble 2
// see MeshGems/Docs/meshgems_formats_description.pdf
/* see MeshGems/Docs/meshgems_formats_description.pdf */
enum GmfKwdCod
{
GmfReserved1, \

2
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -156,7 +156,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
else
_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;
}
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 );
}
@ -379,7 +379,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
if ( myAutoDimension && aMeshDimension < 3 )
{
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
double aBounds[6];
double aBounds[6] = {0.,0.,0.,0.,0.,0.};
if(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = aBounds[1] = aNode->X();

2
src/DriverUNV/UNV164_Structure.hxx
View File

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

2
src/DriverUNV/UNV2411_Structure.hxx
View File

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

2
src/DriverUNV/UNV2412_Structure.hxx
View File

@ -65,7 +65,7 @@ namespace UNV2412{
MESHDRIVERUNV_EXPORT bool
IsVolume(int theFeDescriptorId);
};
}
#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 Write(std::ofstream& out_stream, const TDataSet& theDataSet);
};
}
#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 TDataSet& theDataSet);
};
}
#endif

2
src/DriverUNV/UNV_Utilities.hxx
View File

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

6
src/MEDWrapper/MED_Algorithm.cxx
View File

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

4
src/MEDWrapper/MED_Common.cxx
View File

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

2
src/MEDWrapper/MED_CoordUtils.cxx
View File

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

4
src/MEDWrapper/MED_GaussUtils.cxx
View File

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

9
src/MEDWrapper/MED_Structures.cxx
View File

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

2
src/MEDWrapper/MED_TStructures.hxx
View File

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

4
src/MEDWrapper/MED_Utilities.cxx
View File

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

2
src/MEDWrapper/MED_Utilities.hxx
View File

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

18
src/MEDWrapper/MED_Wrapper.cxx
View File

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

2
src/MEFISTO2/aptrte.cxx
View File

@ -760,7 +760,7 @@ void
#endif
#endif
qualitetrte( R3 *mnpxyd,
Z & mosoar, Z & mxsoar, Z *mnsoar,
Z & mosoar, Z & /*mxsoar*/, Z *mnsoar,
Z & moartr, Z & mxartr, Z *mnartr,
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 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;}
public:
vtkTypeMacro(SMESH_Actor,SALOME_Actor);
vtkTypeMacro(SMESH_Actor,SALOME_Actor)
static SMESH_Actor* New(TVisualObjPtr theVisualObj,
const char* theEntry,
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;
public:
vtkTypeMacro(SMESH_ActorDef,SMESH_Actor);
vtkTypeMacro(SMESH_ActorDef,SMESH_Actor)
virtual void Delete();

4
src/OBJECT/SMESH_CellLabelActor.cxx
View File

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

2
src/OBJECT/SMESH_CellLabelActor.h
View File

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

8
src/OBJECT/SMESH_DeviceActor.cxx
View File

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

2
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -48,7 +48,7 @@ using namespace std;
#endif
vtkStandardNewMacro(SMESH_ExtractGeometry);
vtkStandardNewMacro(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{
public:
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry);
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry)
static SMESH_ExtractGeometry *New();

4
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

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

2
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

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

4
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

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

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

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

2
src/OBJECT/SMESH_SVTKActor.cxx
View File

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

2
src/OBJECT/SMESH_SVTKActor.h
View File

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

8
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -41,11 +41,11 @@
#define SHRINK_COEF 0.08;
vtkStandardNewMacro(SMESH_ScalarBarActor);
vtkStandardNewMacro(SMESH_ScalarBarActor)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty)
//----------------------------------------------------------------------------
// 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:
void PrintSelf(ostream& os, vtkIndent indent);
vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D);
vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D)
// Description:
// 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
{
PLUGINUTILS_EXPORT QString PrintDoubleValue( double, int = 16 );
};
}
#endif // _GEOMSELECTIONTOOLS_H_

34
src/SMDS/SMDS_Downward.cxx
View File

@ -122,7 +122,7 @@ int SMDS_Downward::addCell(int vtkId)
*
* @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.
* @return
*/
int SMDS_Downward::getNumberOfDownCells(int cellId)
int SMDS_Downward::getNumberOfDownCells(int /*cellId*/)
{
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.
* @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];
}
@ -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 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
}
@ -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 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
}
int SMDS_Downward::getNodeSet(int cellId, int* nodeSet)
int SMDS_Downward::getNodeSet(int /*cellId*/, int* /*nodeSet*/)
{
return 0;
}
@ -777,17 +777,17 @@ void SMDS_Down3D::compactStorage()
// nothing to do, size was known before
}
int SMDS_Down3D::getNumberOfUpCells(int cellId)
int SMDS_Down3D::getNumberOfUpCells(int /*cellId*/)
{
return 0;
}
const int* SMDS_Down3D::getUpCells(int cellId)
const int* SMDS_Down3D::getUpCells(int /*cellId*/)
{
return 0;
}
const unsigned char* SMDS_Down3D::getUpTypes(int cellId)
const unsigned char* SMDS_Down3D::getUpTypes(int /*cellId*/)
{
return 0;
}
@ -904,7 +904,7 @@ void SMDS_DownTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesType& e
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(aType == VTK_LINE);
@ -961,7 +961,7 @@ void SMDS_DownQuadTriangle::computeEdgesWithNodes(int cellId, ListElemByNodesTyp
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(aType == VTK_QUADRATIC_EDGE);
@ -1021,7 +1021,7 @@ void SMDS_DownQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesType&
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(aType == VTK_LINE);
@ -1085,7 +1085,7 @@ void SMDS_DownQuadQuadrangle::computeEdgesWithNodes(int cellId, ListElemByNodesT
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(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]);
}
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(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]);
}
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(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]);
}
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));
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]);
}
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));
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 unsigned char* getUpTypes(int cellId) = 0;
virtual void getNodeIds(int cellId, std::set<int>& nodeSet) = 0;
virtual int getNodes(int cellId, int* nodevec) {return 0; }
virtual void getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& orderedNodes) {};
virtual int getNodes(int /*cellId*/, int* /*nodevec*/) {return 0; }
virtual void getOrderedNodesOfFace(int /*cellId*/, std::vector<vtkIdType>& /*orderedNodes*/) {};
int getVtkCellId(int 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
*/
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;
@ -417,7 +417,7 @@ public:
{ min = false; max = true; return myUsedRanges; }
//! 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; }
//! Minimize allocated memory

2
src/SMDS/SMDS_MemoryLimit.cxx
View File

@ -33,7 +33,7 @@
#include <iostream>
#endif
int main (int argc, char ** argv)
int main ()
{
// To better understand what is going on here, consult bug [SALOME platform 0019911]
#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;
#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
* \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 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 Clear();
void Reserve(size_t nbElems) {}
void Reserve(size_t /*nbElems*/) {}
bool Add(const SMDS_MeshElement * theElem);
bool Remove(const SMDS_MeshElement * theElem);
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 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; }
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;
}
bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes*/[], const int /*nbNodes*/)
{
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 bool IsPoly() const { return true; }
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 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 ):
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 )); }
SMDS_Ptr& operator=( const SMDS_Ptr& from )

2
src/SMDS/SMDS_SetIterator.hxx
View File

@ -63,7 +63,7 @@ namespace SMDS {
template <typename VALUE>
struct PassAllValueFilter
{
bool operator()(const VALUE& t ) { return true; }
bool operator()(const VALUE& /*t*/ ) { return true; }
};
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,
std::vector<int>& idNodesOldToNew,
std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied,
int start,
int end)
@ -410,7 +410,7 @@ void SMDS_UnstructuredGrid::CleanDownwardConnectivity()
* 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);
// TODO calcul partiel sans edges
@ -482,6 +482,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges)
GuessSize[VTK_QUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_TRIQUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_HEXAGONAL_PRISM] = nbHexPrism;
(void)GuessSize; // unused in Release mode
_downArray[VTK_LINE] ->allocate(nbLineGuess);
_downArray[VTK_QUADRATIC_EDGE] ->allocate(nbQuadEdgeGuess);

46
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -1328,7 +1328,7 @@ int SMDS_VolumeTool::GetOppFaceIndex( int faceIndex ) const
case 15:
if ( faceIndex == 0 || faceIndex == 1 )
ind = 1 - faceIndex;
break;
break;
case 8:
case 12:
if ( faceIndex <= 1 ) // top or bottom
@ -1488,10 +1488,10 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_TETRA:
{
switch ( minInd ) {
case 0: if( maxInd==4 || maxInd==6 || maxInd==7 ) return true;
case 1: if( maxInd==4 || maxInd==5 || maxInd==8 ) return true;
case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true;
case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) 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; // fall through
case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true; // fall through
case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) return true; // fall through
default:;
}
break;
@ -1499,14 +1499,14 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_HEXA:
{
switch ( minInd ) {
case 0: if( maxInd==8 || maxInd==11 || maxInd==16 ) return true;
case 1: if( maxInd==8 || maxInd==9 || maxInd==17 ) return true;
case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true;
case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true;
case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true;
case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true;
case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true;
case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) 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; // fall through
case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true; // fall through
case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true; // fall through
case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true; // fall through
case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true; // fall through
case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true; // fall through
case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) return true; // fall through
default:;
}
break;
@ -1514,10 +1514,10 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_PYRAM:
{
switch ( minInd ) {
case 0: if( maxInd==5 || maxInd==8 || maxInd==9 ) return true;
case 1: if( maxInd==5 || maxInd==6 || maxInd==10 ) return true;
case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true;
case 3: if( maxInd==7 || maxInd==8 || maxInd==12 ) 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; // fall through
case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true; // fall through
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;
default:;
}
@ -1526,12 +1526,12 @@ bool SMDS_VolumeTool::IsLinked (const int theNode1Index,
case QUAD_PENTA:
{
switch ( minInd ) {
case 0: if( maxInd==6 || maxInd==8 || maxInd==12 ) return true;
case 1: if( maxInd==6 || maxInd==7 || maxInd==13 ) return true;
case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true;
case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true;
case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true;
case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) 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; // fall through
case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true; // fall through
case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true; // fall through
case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true; // fall through
case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) return true; // fall through
default:;
}
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;
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
catch (Standard_Failure) {
catch (Standard_Failure&) {
}
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
//=======================================================================
bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{
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
//=======================================================================
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() );
}
@ -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
//=======================================================================
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() );
}
@ -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
//=======================================================================
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() );
}

15
src/SMESH/SMESH_Gen.cxx
View File

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

3
src/SMESH/SMESH_Gen.hxx
View File

@ -67,8 +67,7 @@ public:
SMESH_Gen();
~SMESH_Gen();
SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
throw(SALOME_Exception);
SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
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
{
return aHyp->GetType();
};
}
//=======================================================================
//function : DimPredicate::Value
@ -78,7 +78,7 @@ bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
const TopoDS_Shape& /*aShape*/) const
{
return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
};
}
//=======================================================================
//function : IsAuxiliaryPredicate::IsOk
@ -89,7 +89,7 @@ bool SMESH_HypoFilter::IsAuxiliaryPredicate::IsOk(const SMESH_Hypothesis* aHyp,
const TopoDS_Shape& /*aShape*/) const
{
return aHyp->IsAuxiliary();
};
}
//=======================================================================
//function : ApplicablePredicate::ApplicablePredicate
@ -117,7 +117,7 @@ bool SMESH_HypoFilter::InstancePredicate::IsOk(const SMESH_Hypothesis* aHyp,
//purpose :
//=======================================================================
bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp,
bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* /*aHyp*/,
const TopoDS_Shape& aShape) const
{
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 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 )
{

132
src/SMESH/SMESH_Mesh.cxx
View File

@ -618,7 +618,7 @@ SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName,
SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
int anHypId,
std::string* anError ) throw(SALOME_Exception)
std::string* anError )
{
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
@ -713,7 +713,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
int anHypId) throw( SALOME_Exception )
int anHypId)
{
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
@ -784,7 +784,6 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
const std::list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{
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);
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);
_myMeshDS->GetScript()->Clear();
@ -1017,7 +1016,6 @@ void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
//=============================================================================
SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
throw(SALOME_Exception)
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
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
throw(SALOME_Exception)
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
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
throw(SALOME_Exception)
{
SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
return aSubMesh;
}
@ -1099,7 +1094,6 @@ throw(SALOME_Exception)
std::list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{
std::list<SMESH_subMesh*> found;
@ -1273,13 +1267,13 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
* Auto color functionality
*/
//=============================================================================
void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception)
void SMESH_Mesh::SetAutoColor(bool theAutoColor)
{
Unexpect aCatch(SalomeException);
_isAutoColor = theAutoColor;
}
bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
bool SMESH_Mesh::GetAutoColor()
{
Unexpect aCatch(SalomeException);
return _isAutoColor;
@ -1432,7 +1426,6 @@ void SMESH_Mesh::ExportMED(const char * file,
bool theAddODOnVertices,
double theZTolerance,
bool theAllElemsToGroup)
throw(SALOME_Exception)
{
MESSAGE("MED_VERSION:"<< theVersion);
SMESH_TRY;
@ -1503,7 +1496,6 @@ throw(SALOME_Exception)
void SMESH_Mesh::ExportSAUV(const char *file,
const char* theMeshName,
bool theAutoGroups)
throw(SALOME_Exception)
{
std::string medfilename(file);
medfilename += ".med";
@ -1547,7 +1539,7 @@ void SMESH_Mesh::ExportSAUV(const char *file,
//================================================================================
void SMESH_Mesh::ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverDAT_W_SMDS_Mesh myWriter;
@ -1564,7 +1556,7 @@ void SMESH_Mesh::ExportDAT(const char * file,
//================================================================================
void SMESH_Mesh::ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverUNV_W_SMDS_Mesh myWriter;
@ -1599,7 +1591,7 @@ void SMESH_Mesh::ExportUNV(const char * file,
void SMESH_Mesh::ExportSTL(const char * file,
const bool isascii,
const char * name,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
int SMESH_Mesh::NbQuadPrisms() const throw (SALOME_Exception)
int SMESH_Mesh::NbQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms();
}
int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
int SMESH_Mesh::NbBiQuadPrisms() const
{
Unexpect aCatch(SalomeException);
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);
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);
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);
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);
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 )
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
{
if ( !_mySubMeshOrder.size() || theListToSort.size() < 2)
if ( _mySubMeshOrder.empty() || theListToSort.size() < 2 )
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
std::vector<SMESH_subMesh*> smVec;
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();
TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin();
bool needSort = false;
for( ; listIdsIt != _mySubMeshOrder.end(); listIdsIt++)
{
const TListOfInt& listOfId = *listIdsIt;
@ -2452,27 +2445,46 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) con
// find smVec items in theListToSort
for ( size_t i = 0; i < smVec.size(); ++i )
{
TPosInList smPos = find( smBeg, smEnd, smVec[i] );
if ( smPos != smEnd ) {
sortedPos[ std::distance( smBeg, smPos )] = smPos;
if ( sortedPos.size() > onlyOrderedList.size() )
onlyOrderedList.push_back( smVec[i] );
TPosInList smPos = find( smBeg, smEnd, smVec[i] ); // position in theListToSort
if ( smPos != smEnd )
{
size_t posInList = std::distance( smBeg, smPos );
size_t order = sortedPos.size();
sortedPos.insert( std::make_pair( posInList, order ));
if ( posInList != order )
needSort = true;
}
}
}
if (onlyOrderedList.size() < 2)
return res;
res = true;
if ( ! needSort )
return false;
std::vector<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
std::vector<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
// set sm of sortedPos from theListToSort to front of orderedSM
// and the rest of theListToSort to orderedSM end
// iterate on ordered sub-meshes and insert them in detected positions
std::map< int, TPosInList >::iterator i_pos = sortedPos.begin();
for ( ; onlyBIt != onlyEIt; ++onlyBIt, ++i_pos )
*(i_pos->second) = *onlyBIt;
std::vector<SMESH_subMesh*> orderedSM;
orderedSM.reserve( theListToSort.size() );
orderedSM.resize( sortedPos.size() );
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 );
SMESH_Hypothesis::Hypothesis_Status
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
throw(SALOME_Exception);
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
SMESH_Hypothesis::Hypothesis_Status
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
throw(SALOME_Exception);
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
const std::list <const SMESHDS_Hypothesis * >&
GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception);
GetHypothesisList(const TopoDS_Shape & aSubShape) const;
const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape,
const SMESH_HypoFilter& aFilter,
@ -167,9 +164,9 @@ class SMESH_EXPORT SMESH_Mesh
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; }
@ -183,19 +180,15 @@ class SMESH_EXPORT SMESH_Mesh
SMESH_Gen *GetGen() { return _gen; }
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
throw(SALOME_Exception);
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape);
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception);
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
throw(SALOME_Exception);
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const;
/*!
* \brief Return submeshes of groups containing the given subshape
*/
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
throw(SALOME_Exception);
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const;
/*!
* \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;
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".
@ -266,17 +259,16 @@ class SMESH_EXPORT SMESH_Mesh
bool theAutoDimension = false,
bool theAddODOnVertices = false,
double theZTolerance = -1.,
bool theAllElemsToGroup = false)
throw(SALOME_Exception);
bool theAllElemsToGroup = false);
void ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
const SMESHDS_Mesh* meshPart = 0);
void ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
const SMESHDS_Mesh* meshPart = 0);
void ExportSTL(const char * file,
const bool isascii,
const char * name = 0,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
const SMESHDS_Mesh* meshPart = 0);
void ExportCGNS(const char * file,
const SMESHDS_Mesh* mesh,
const char * meshName = 0,
@ -286,35 +278,35 @@ class SMESH_EXPORT SMESH_Mesh
bool withRequiredGroups = true );
void ExportSAUV(const char *file,
const char* theMeshName = NULL,
bool theAutoGroups = true) throw(SALOME_Exception);
bool theAutoGroups = true);
double GetComputeProgress() const;
int NbNodes() const throw(SALOME_Exception);
int Nb0DElements() const throw(SALOME_Exception);
int NbBalls() const throw(SALOME_Exception);
int NbNodes() const;
int Nb0DElements() const;
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 NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbBiQuadQuadrangles() const throw(SALOME_Exception);
int NbBiQuadTriangles() const throw(SALOME_Exception);
int NbPolygons(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;
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbBiQuadQuadrangles() const;
int NbBiQuadTriangles() const;
int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbTriQuadraticHexas() const throw(SALOME_Exception);
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
int NbQuadPrisms() const throw(SALOME_Exception);
int NbBiQuadPrisms() const throw(SALOME_Exception);
int NbHexagonalPrisms() const throw(SALOME_Exception);
int NbPolyhedrons() const throw(SALOME_Exception);
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadraticHexas() const;
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadPrisms() const;
int NbBiQuadPrisms() const;
int NbHexagonalPrisms() const;
int NbPolyhedrons() const;
int NbSubMesh() const throw(SALOME_Exception);
int NbSubMesh() const;
int NbGroup() const { return _mapGroup.size(); }
@ -326,7 +318,7 @@ class SMESH_EXPORT SMESH_Mesh
const TopoDS_Shape& theShape = TopoDS_Shape(),
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;
GroupIteratorPtr GetGroups() const;

20
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -3857,9 +3857,9 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
}
else {
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 )
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
// if ( posType != SMDS_TOP_3DSPACE )
// dist2 = pNode.SquareDistance( surface->Value( newUV.X(), newUV.Y() ));
@ -5666,10 +5666,10 @@ makeNodesByNormal2D( SMESHDS_Mesh* mesh,
//=======================================================================
int SMESH_MeshEditor::ExtrusParam::
makeNodesByNormal1D( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes,
const bool makeMediumNodes)
makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
const SMDS_MeshNode* /*srcNode*/,
std::list<const SMDS_MeshNode*> & /*newNodes*/,
const bool /*makeMediumNodes*/)
{
throw SALOME_Exception("Extrusion 1D by Normal not implemented");
return 0;
@ -6070,6 +6070,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
if ( nbEdges > 0 )
break;
}
// fall through
default:
{
for ( int di = -1; di <= 1; di += 2 )
@ -7460,6 +7461,7 @@ public:
//int& GroupID() const { return const_cast< int& >( myGroupID ); }
ComparableElement( const ComparableElement& theSource ) // move copy
: boost::container::flat_set< int >()
{
ComparableElement& src = const_cast< ComparableElement& >( theSource );
(int_set&) (*this ) = boost::move( src );
@ -9216,7 +9218,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int theShapeID)
const int /*theShapeID*/)
{
int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS();
@ -10198,7 +10200,7 @@ namespace // automatically find theAffectedElems for DoubleNodes()
if ( SMESH_MeshAlgos::FaceNormal( _elems[1], 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;
}
else
@ -11045,7 +11047,7 @@ double SMESH_MeshEditor::OrientedAngle(const gp_Pnt& p0, const gp_Pnt& p1, const
try {
return n2.AngleWithRef(n1, vref);
}
catch ( Standard_Failure ) {
catch ( Standard_Failure& ) {
}
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* n12,
const int id,
bool force3d)
bool /*force3d*/)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
SMDS_MeshVolume* elem = 0;
@ -3769,7 +3769,7 @@ namespace { // Structures used by FixQuadraticElements()
/*!
* \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: "
<< l.node1()->GetID() << " - "
@ -3777,7 +3777,7 @@ namespace { // Structures used by FixQuadraticElements()
<< l.node2()->GetID() << endl;
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 << " "*/;
for ( TIDSortedNodeSet::const_iterator n = f.begin(); n != f.end(); ++n )
@ -3820,6 +3820,7 @@ namespace { // Structures used by FixQuadraticElements()
#ifdef _DEBUG_
_face = face;
#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
gp_XYZ gc(0,0,0);
@ -4613,7 +4614,7 @@ namespace { // Structures used by FixQuadraticElements()
if ( curvNorm * D2 > 0 )
continue; // convex edge
}
catch ( Standard_Failure )
catch ( Standard_Failure& )
{
continue;
}
@ -4728,7 +4729,7 @@ namespace { // Structures used by FixQuadraticElements()
if ( concaveU || concaveV )
concaveFaces.push_back( face );
}
catch ( Standard_Failure )
catch ( Standard_Failure& )
{
concaveFaces.push_back( face );
}
@ -5260,7 +5261,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
try {
gp_Vec x = x01.Normalized() + x12.Normalized();
trsf.SetTransformation( gp_Ax3( gp::Origin(), link1->Normal(), x), gp_Ax3() );
} catch ( Standard_Failure ) {
} catch ( Standard_Failure& ) {
trsf.Invert();
}
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 '+':
case '.':
isNumber = true;
isNumber = true; // fall through
default: // data
isNumber = isNumber || ( *theLineBeg >= '0' && *theLineBeg <= '9' );
if ( isNumber ) {
@ -4289,11 +4289,13 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5] ); break;
} // else do not break but create a polygon
// fall through
case 8:
if ( !onMeshElements ) {// create a quadratic face
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7] ); break;
} // else do not break but create a polygon
// fall through
default:
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
virtual SMDS_ElemIteratorPtr getElements() { Clear(); return GetElements(); }
virtual void tmpClear() {}
virtual void add( const SMDS_MeshElement* element ) {}
virtual void add( const SMDS_MeshElement* /*element*/ ) {}
virtual void compact() {}
virtual void clear() { Clear(); }
};

5
src/SMESH/SMESH_subMesh.cxx
View File

@ -1445,6 +1445,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
// fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
@ -1496,6 +1497,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
}
break;
}
// fall through
case COMPUTE:
case COMPUTE_SUBMESH:
{
@ -1763,6 +1765,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
// fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
@ -2149,7 +2152,7 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
// 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,
bool & theSubComputed,
bool & theSubFailed,

4
src/SMESH/SMESH_subMeshEventListener.hxx
View File

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

6
src/SMESHClient/SMESH_Client.cxx
View File

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

4
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -273,7 +273,7 @@ bool SMESHDS_Mesh
//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.
if ( !this->IsCompacted() )
@ -838,7 +838,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
//purpose :
//=======================================================================
static void removeFromContainers (SMESHDS_Mesh* theMesh,
static void removeFromContainers (SMESHDS_Mesh* /*theMesh*/,
std::set<SMESHDS_GroupBase*>& theGroups,
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;
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();
}
catch (...) { // PAL16774 (Crash after display of many groups)
@ -2865,7 +2865,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpCreateSubMesh:
if ( warnOnGeomModif() )
break; // action forbiden as geometry modified
// fall through
case SMESHOp::OpCreateMesh:
case SMESHOp::OpCompute:
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;
}
@ -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;
}
@ -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;
}
@ -5332,7 +5332,7 @@ void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
void* theCallData )
void* /*theCallData*/ )
{
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {

6
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

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

4
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

@ -81,7 +81,7 @@ namespace SMESH
public:
static OrientedPlane *New();
static OrientedPlane *New(SVTK_ViewWindow* theViewWindow);
vtkTypeMacro (OrientedPlane, vtkPlane);
vtkTypeMacro (OrientedPlane, vtkPlane)
QPointer<SVTK_ViewWindow> myViewWindow;
SMESH::Orientation myRelativeOrientation;
@ -135,7 +135,7 @@ namespace SMESH
typedef std::vector<TPlane> TPlaneVector;
typedef std::vector<TPlaneData> TPlaneDataVector;
};
}
//=================================================================================
// 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
*/
void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int column)
void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int /*column*/)
{
myTree->blockSignals( true );
if ( !item->parent() ) // mesh item

2
src/SMESHGUI/SMESHGUI_Filter.h
View File

@ -55,7 +55,7 @@ namespace SMESH
FirstEntityTypeFilter = FirstGeometryTypeFilter + SMDSGeom_NONE,
LastFilter = FirstEntityTypeFilter + SMDSEntity_Last
};
};
}
/*
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,
const QStyleOptionViewItem& option,
const QModelIndex& index ) const
const QModelIndex& /*index*/ ) const
{
editor->setGeometry( option.rect );
}
@ -1732,6 +1732,7 @@ static QList<int> entityTypes( const int theType )
{
case SMESH::NODE:
typeIds.append( SMDSEntity_Node );
break;
case SMESH::EDGE:
typeIds.append( SMDSEntity_Edge );
typeIds.append( SMDSEntity_Quad_Edge );
@ -1776,7 +1777,7 @@ static QList<int> entityTypes( const int theType )
// 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;
Table* aTable = myTables[ aType ];
@ -2377,7 +2378,7 @@ const QMap<int, QString>& SMESHGUI_FilterTable::getCompare() const
// Purpose : Create table
//=======================================================================
SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent,
const int theType)
const int /*theType*/)
{
// create table
Table* aTable= new Table(0, 6, theParent);
@ -3816,6 +3817,7 @@ void SMESHGUI_FilterDlg::onSelectionDone()
myTable->SetThreshold(aRow, SMESH::toQStr( grp->GetName() ));
myTable->SetID (aRow, anIO->getEntry() );
}
break;
}
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
// 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())
return;
@ -1244,6 +1244,7 @@ void SMESHGUI_FilterLibraryDlg::onSelectionDone()
case SMESH::FT_BelongToMeshGroup: // get a group name and IOR
{
myTable->SetThreshold(aRow, anIO->getName() );
break;
}
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_ptr gen;
GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go ))
gen = go->GetGen();
return gen;

4
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

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

2
src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
View File

@ -592,7 +592,7 @@ namespace SMESH
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString& aHypType,
const QString& aHypName,
const bool isAlgo)
const bool /*isAlgo*/)
{
if(MYDEBUG) MESSAGE("Create " << aHypType.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;

10
src/SMESHGUI/SMESHGUI_Measurements.h
View File

@ -46,7 +46,7 @@ class SMESHGUI_MeshEditPreview;
class SMESHGUI_EXPORT SMESHGUI_MinDistance : public QWidget
{
Q_OBJECT;
Q_OBJECT
enum { NoTgt, FirstTgt, SecondTgt };
enum { OriginTgt, NodeTgt, ElementTgt, ObjectTgt };
@ -95,7 +95,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_BoundingBox : public QWidget
{
Q_OBJECT;
Q_OBJECT
enum { ObjectsSrc, NodesSrc, ElementsSrc };
@ -141,7 +141,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_BasicProperties : public QWidget
{
Q_OBJECT;
Q_OBJECT
public:
//! Property type
@ -172,7 +172,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_Angle : public QWidget
{
Q_OBJECT;
Q_OBJECT
public:
@ -206,7 +206,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_MeasureDlg : public QDialog
{
Q_OBJECT;
Q_OBJECT
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
//=======================================================================
void SMESHGUI_MergeDlg::onKeepSourceChanged(int isGroup)
void SMESHGUI_MergeDlg::onKeepSourceChanged(int /*isGroup*/)
{
KeepList->clear();
SelectKeepButton->click();

2
src/SMESHGUI/SMESHGUI_MergeDlg.h
View File

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

12
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -1804,8 +1804,8 @@ void SMESHGUI_ElemInfo::writeInfo( InfoWriter* writer, const QList<uint>& ids )
writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
}
int size = group.size();
if ( size != -1 );
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
if ( size != -1 )
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color();
if ( color.isValid() )
writer->write( SMESHGUI_AddInfo::tr( "COLOR" ), color.name() );
@ -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" ) );
}
int size = group.size();
if ( size != -1 );
if ( size != -1 )
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color();
if ( color.isValid() )
@ -2175,8 +2175,8 @@ void SMESHGUI_TreeElemInfo::information( const QList<uint>& ids )
\param nbNodes number of unique nodes in element
\param parentItem parent item of tree
*/
void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
int nbNodes, QTreeWidgetItem* parentItem )
void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* /*node*/, int /*index*/,
int /*nbNodes*/, QTreeWidgetItem* /*parentItem*/ )
{
// int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
// // 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 ) {
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
{
Q_OBJECT;
Q_OBJECT
enum
{
@ -158,7 +158,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_ElemInfo : public SMESHGUI_Info
{
Q_OBJECT;
Q_OBJECT
public:
SMESHGUI_ElemInfo( QWidget* = 0 );
@ -205,7 +205,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_SimpleElemInfo : public SMESHGUI_ElemInfo
{
Q_OBJECT;
Q_OBJECT
public:
SMESHGUI_SimpleElemInfo( QWidget* = 0 );
@ -223,7 +223,7 @@ private slots:
class SMESHGUI_EXPORT SMESHGUI_TreeElemInfo : public SMESHGUI_ElemInfo
{
Q_OBJECT;
Q_OBJECT
class ItemDelegate;
class ItemCreator;
@ -251,7 +251,7 @@ private:
class InfoComputor: public QObject
{
Q_OBJECT;
Q_OBJECT
public:
enum { GrpSize, GrpNbNodes };
@ -271,7 +271,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_AddInfo : public SMESHGUI_Info
{
Q_OBJECT;
Q_OBJECT
public:
SMESHGUI_AddInfo( QWidget* = 0 );
@ -307,7 +307,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_CtrlInfo : public SMESHGUI_Info
{
Q_OBJECT;
Q_OBJECT
public:
SMESHGUI_CtrlInfo( QWidget* = 0 );
@ -354,7 +354,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_MeshInfoDlg : public QDialog
{
Q_OBJECT;
Q_OBJECT
enum { NodeMode, ElemMode, GroupMode };
@ -409,7 +409,7 @@ private:
class SMESHGUI_EXPORT SMESHGUI_CtrlInfoDlg : public QDialog
{
Q_OBJECT;
Q_OBJECT
public:
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,
HypothesisData* thePrevAlgoData,
HypothesisData* theNextAlgoData,
const QString& theMeshType)
const QString& /*theMeshType*/)
{
theDataList.clear();
theHyps.clear();
@ -1434,7 +1434,7 @@ void SMESHGUI_MeshOp::onEditHyp( const int theHypType, const int theIndex )
* 1 = accepted
*/
//================================================================================
void SMESHGUI_MeshOp::onHypoEdited( int result )
void SMESHGUI_MeshOp::onHypoEdited( int /*result*/ )
{
int obj = myDlg->getActiveObject();
onActivateObject( obj ); // Issue 0020170. Restore filters
@ -2975,7 +2975,7 @@ void SMESHGUI_MeshOp::updateHypoSets()
* \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();
}

1
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

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

2
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -395,7 +395,7 @@ void SMESHGUI_NodesDlg::Init()
// function : ValueChangedInSpinBox()
// purpose :
//=================================================================================
void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double newValue )
void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double /*newValue*/ )
{
if ( !myMesh->_is_nil() ) {
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;
}
bool SMESHGUI_PreVisualObj::Update( int theIsClear = true )
bool SMESHGUI_PreVisualObj::Update( int /*theIsClear*/)
{
return false;
}

4
src/SMESHGUI/SMESHGUI_PreviewDlg.cxx
View File

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

2
src/SMESHGUI/SMESHGUI_RenumberingDlg.cxx
View File

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

2
src/SMESHGUI/SMESHGUI_RevolutionDlg.cxx
View File

@ -573,7 +573,7 @@ void SMESHGUI_RevolutionDlg::ClickOnHelp()
// function : onAngleTextChange()
// purpose :
//=======================================================================
void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& theNewText)
void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& /*theNewText*/)
{
bool 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
// purpose :
//=================================================================================
void SMESHGUI_SelectionOp::onDeactivateObject( int id )
void SMESHGUI_SelectionOp::onDeactivateObject( int /*id*/ )
{
removeCustomFilters();
}

10
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.node2 = ( aPRT.node2 + size + dn ) % size;
break;
}
break;
case MOVE_LEFT_2:
case MOVE_RIGHT_2:
if (( isClosed ) ||
( 0 <= aPRT.nodeLast+dn && aPRT.nodeLast+dn < size ))
{
aPRT.nodeLast = ( aPRT.nodeLast + size + dn ) % size;
break;
}
break;
default:
return; // impossible to move
}
@ -1584,8 +1584,8 @@ void SMESHGUI_SewingDlg::onTextChange (const QString& theNewText)
if (e)
newIndices.Add(e->GetID());
if (!isEvenOneExists)
isEvenOneExists = true;
if (!isEvenOneExists)
isEvenOneExists = true;
}
mySelector->AddOrRemoveIndex(myActor->getIO(), newIndices, false);
@ -1798,7 +1798,7 @@ void SMESHGUI_SewingDlg::ActivateThisDialog()
// function : enterEvent()
// purpose :
//=================================================================================
void SMESHGUI_SewingDlg::enterEvent (QEvent* e)
void SMESHGUI_SewingDlg::enterEvent (QEvent* /*e*/)
{
if (!ConstructorsBox->isEnabled()) {
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.
//=======================================================================
void SMESHGUI_ShapeByMeshOp::onTypeChanged (int theType)
void SMESHGUI_ShapeByMeshOp::onTypeChanged (int /*theType*/)
{
setElementID("");
activateSelection();

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