ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-15 21:01:26 +05:00
Code Issues Packages Projects Releases Wiki Activity

fight warnings, c++17. Fix minor warnings. Buils SMESH finished

Browse Source
This commit is contained in:
SALOME 2020-08-27 16:24:57 +03:00
parent 44c1e310f0
commit f83eeba172
88 changed files with 215 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Controls/SMESH_Controls.cxx
View File

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

2
src/Controls/SMESH_ControlsDef.hxx
View File

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

2
src/DriverUNV/UNV164_Structure.hxx
View File

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

2
src/DriverUNV/UNV2411_Structure.hxx
View File

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

2
src/DriverUNV/UNV2412_Structure.hxx
View File

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

2
src/DriverUNV/UNV2417_Structure.hxx
View File

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

2
src/DriverUNV/UNV2420_Structure.hxx
View File

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

2
src/DriverUNV/UNV_Utilities.hxx
View File

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

2
src/MEDWrapper/MED_Algorithm.cxx
View File

@ -178,7 +178,7 @@ namespace MED
//--------------------------------------------------------------- //---------------------------------------------------------------
TEntity2FamilySet TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper, GetEntity2FamilySet(const PWrapper& /*theWrapper*/,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo, const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet) const TFamilyInfoSet& theFamilyInfoSet)
{ {

2
src/MEDWrapper/MED_Algorithm.hxx
View File

@ -53,7 +53,7 @@ namespace MED
//! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
MEDWRAPPER_EXPORT MEDWRAPPER_EXPORT
TEntity2TGeom2ElemInfo TEntity2TGeom2ElemInfo
GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper, GetEntity2TGeom2ElemInfo(const PWrapper& /*theWrapper*/,
const PMeshInfo& theMeshInfo, const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo); const MED::TEntityInfo& theEntityInfo);

2
src/MEFISTO2/aptrte.cxx
View File

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

2
src/OBJECT/SMESH_Actor.h
View File

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

2
src/OBJECT/SMESH_ActorDef.h
View File

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

2
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -44,7 +44,7 @@
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
#include <vtkCellData.h> #include <vtkCellData.h>
vtkStandardNewMacro(SMESH_CellLabelActor); vtkStandardNewMacro(SMESH_CellLabelActor)
/*! /*!
Constructor. Constructor.

2
src/OBJECT/SMESH_CellLabelActor.h
View File

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

2
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -77,7 +77,7 @@ static int MYDEBUG = 0;
using namespace std; using namespace std;
vtkStandardNewMacro(SMESH_DeviceActor); vtkStandardNewMacro(SMESH_DeviceActor)
SMESH_DeviceActor SMESH_DeviceActor

2
src/OBJECT/SMESH_DeviceActor.h
View File

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

2
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

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

2
src/OBJECT/SMESH_ExtractGeometry.h
View File

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

4
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

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

2
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

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

2
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -39,7 +39,7 @@
#include <vtkRenderer.h> #include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
vtkStandardNewMacro(SMESH_NodeLabelActor); vtkStandardNewMacro(SMESH_NodeLabelActor)
/*! /*!
Constructor. Constructor.

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

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

2
src/OBJECT/SMESH_SVTKActor.cxx
View File

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

2
src/OBJECT/SMESH_SVTKActor.h
View File

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

2
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -41,7 +41,7 @@
#define SHRINK_COEF 0.08; #define SHRINK_COEF 0.08;
vtkStandardNewMacro(SMESH_ScalarBarActor); vtkStandardNewMacro(SMESH_ScalarBarActor)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors); vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty); vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);

2
src/OBJECT/SMESH_ScalarBarActor.h
View File

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

2
src/SMDS/SMDS_MeshGroup.hxx
View File

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

2
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
View File

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

4
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -336,7 +336,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
} }
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints, void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& idNodesOldToNew, std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied, int& alreadyCopied,
int start, int start,
int end) int end)
@ -410,7 +410,7 @@ void SMDS_UnstructuredGrid::CleanDownwardConnectivity()
* Downward connectivity is no more valid if vtkUnstructuredGrid is modified. * Downward connectivity is no more valid if vtkUnstructuredGrid is modified.
* *
*/ */
void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
{ {
MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2); MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2);
// TODO calcul partiel sans edges // TODO calcul partiel sans edges

4
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -85,7 +85,7 @@ public:
int CellIdToDownId(int vtkCellId); int CellIdToDownId(int vtkCellId);
void setCellIdToDownId(int vtkCellId, int downId); void setCellIdToDownId(int vtkCellId, int downId);
void CleanDownwardConnectivity(); void CleanDownwardConnectivity();
void BuildDownwardConnectivity(bool withEdges); void BuildDownwardConnectivity(bool /*withEdges*/);
int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false); int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false);
int GetParentVolumes(int* volVtkIds, int vtkId); int GetParentVolumes(int* volVtkIds, int vtkId);
int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType); int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType);
@ -115,7 +115,7 @@ public:
protected: protected:
SMDS_UnstructuredGrid(); SMDS_UnstructuredGrid();
~SMDS_UnstructuredGrid(); ~SMDS_UnstructuredGrid();
void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end); void copyNodes(vtkPoints *newPoints, std::vector<int>& /*idNodesOldToNew*/, int& alreadyCopied, int start, int end);
void copyBloc(vtkUnsignedCharArray *newTypes, void copyBloc(vtkUnsignedCharArray *newTypes,
const std::vector<int>& idCellsOldToNew, const std::vector<int>& idCellsOldToNew,
const std::vector<int>& idNodesOldToNew, const std::vector<int>& idNodesOldToNew,

2
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -1328,7 +1328,7 @@ int SMDS_VolumeTool::GetOppFaceIndex( int faceIndex ) const
case 15: case 15:
if ( faceIndex == 0 || faceIndex == 1 ) if ( faceIndex == 0 || faceIndex == 1 )
ind = 1 - faceIndex; ind = 1 - faceIndex;
break; break;
case 8: case 8:
case 12: case 12:
if ( faceIndex <= 1 ) // top or bottom if ( faceIndex <= 1 ) // top or bottom

8
src/SMESH/SMESH_Algo.cxx
View File

@ -858,7 +858,7 @@ bool SMESH_Algo::Compute(SMESH_Mesh & /*aMesh*/, SMESH_MesherHelper* /*aHelper*/
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{ {
return true; return true;
} }
@ -1261,7 +1261,7 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh,
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
} }
@ -1271,7 +1271,7 @@ bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
} }
@ -1281,7 +1281,7 @@ bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//purpose : Return true if the algorithm can mesh a given shape //purpose : Return true if the algorithm can mesh a given shape
//======================================================================= //=======================================================================
bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{ {
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() ); return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
} }

8
src/SMESH/SMESH_Algo.hxx
View File

@ -173,7 +173,7 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const; virtual bool IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const;
/*! /*!
* \brief Sets _computeCanceled to true. It's usage depends on * \brief Sets _computeCanceled to true. It's usage depends on
@ -480,7 +480,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
}; };
class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo
@ -494,7 +494,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
/*! /*!
* \brief Method in which an algorithm generating a structured mesh * \brief Method in which an algorithm generating a structured mesh
* fixes positions of in-face nodes after there movement * fixes positions of in-face nodes after there movement
@ -515,7 +515,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
}; };
#endif #endif

8
src/SMESH/SMESH_Gen.cxx
View File

@ -415,8 +415,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
* Prepare Compute a mesh * Prepare Compute a mesh
*/ */
//============================================================================= //=============================================================================
void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape) const TopoDS_Shape & /*aShape*/)
{ {
_compute_canceled = false; _compute_canceled = false;
resetCurrentSubMesh(); resetCurrentSubMesh();
@ -427,8 +427,8 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
* Cancel Compute a mesh * Cancel Compute a mesh
*/ */
//============================================================================= //=============================================================================
void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape) const TopoDS_Shape & /*aShape*/)
{ {
_compute_canceled = true; _compute_canceled = true;
if ( const SMESH_subMesh* sm = GetCurrentSubMesh() ) if ( const SMESH_subMesh* sm = GetCurrentSubMesh() )

8
src/SMESH/SMESH_Gen.hxx
View File

@ -91,10 +91,10 @@ public:
const ::MeshDimension aDim=::MeshDim_3D, const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0); TSetOfInt* aShapesId=0);
void PrepareCompute(::SMESH_Mesh & aMesh, void PrepareCompute(::SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape); const TopoDS_Shape & /*aShape*/);
void CancelCompute(::SMESH_Mesh & aMesh, void CancelCompute(::SMESH_Mesh & /*aMesh*/,
const TopoDS_Shape & aShape); const TopoDS_Shape & /*aShape*/);
const SMESH_subMesh* GetCurrentSubMesh() const; const SMESH_subMesh* GetCurrentSubMesh() const;

2
src/SMESH/SMESH_HypoFilter.hxx
View File

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

10
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -5652,10 +5652,10 @@ makeNodesByNormal2D( SMESHDS_Mesh* mesh,
//======================================================================= //=======================================================================
int SMESH_MeshEditor::ExtrusParam:: int SMESH_MeshEditor::ExtrusParam::
makeNodesByNormal1D( SMESHDS_Mesh* mesh, makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* /*srcNode*/,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & /*newNodes*/,
const bool makeMediumNodes) const bool /*makeMediumNodes*/)
{ {
throw SALOME_Exception("Extrusion 1D by Normal not implemented"); throw SALOME_Exception("Extrusion 1D by Normal not implemented");
return 0; return 0;
@ -9202,7 +9202,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm, int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr, SMDS_ElemIteratorPtr theItr,
const int theShapeID) const int /*theShapeID*/)
{ {
int nbElem = 0; int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS(); SMESHDS_Mesh* meshDS = GetMeshDS();

10
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -395,10 +395,10 @@ public:
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & newNodes,
const bool makeMediumNodes); const bool makeMediumNodes);
int makeNodesByNormal1D( SMESHDS_Mesh* mesh, int makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* /*srcNode*/,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & /*newNodes*/,
const bool makeMediumNodes); const bool /*makeMediumNodes*/);
int makeNodesAlongTrack( SMESHDS_Mesh* mesh, int makeNodesAlongTrack( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & newNodes,
@ -747,7 +747,7 @@ public:
*/ */
int removeQuadElem( SMESHDS_SubMesh * theSm, int removeQuadElem( SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr, SMDS_ElemIteratorPtr theItr,
const int theShapeID); const int /*theShapeID*/);
/*! /*!
* \brief Create groups of elements made during transformation * \brief Create groups of elements made during transformation
* \param nodeGens - nodes making corresponding myLastCreatedNodes * \param nodeGens - nodes making corresponding myLastCreatedNodes

2
src/SMESH/SMESH_subMesh.cxx
View File

@ -2106,7 +2106,7 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
// meshed at once along with _subShape // meshed at once along with _subShape
//======================================================================= //=======================================================================
TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen, TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed, bool & theSubComputed,
bool & theSubFailed, bool & theSubFailed,

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -294,7 +294,7 @@ protected:
* \brief Return a shape containing all sub-shapes of the MainShape that can be * \brief Return a shape containing all sub-shapes of the MainShape that can be
* meshed at once along with _subShape * meshed at once along with _subShape
*/ */
TopoDS_Shape getCollection(SMESH_Gen * theGen, TopoDS_Shape getCollection(SMESH_Gen * /*theGen*/,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed, bool & theSubComputed,
bool & theSubFailed, bool & theSubFailed,

4
src/SMESH/SMESH_subMeshEventListener.hxx
View File

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

8
src/SMESHGUI/SMESHGUI.cxx
View File

@ -3961,7 +3961,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return false; return false;
} }
@ -3971,7 +3971,7 @@ bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return true; return true;
} }
@ -3981,7 +3981,7 @@ bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
* *
*/ */
//============================================================================= //=============================================================================
bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd ) bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{ {
return true; return true;
} }
@ -5270,7 +5270,7 @@ void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
void SMESHGUI::ProcessEvents( vtkObject* theObject, void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent, unsigned long theEvent,
void* theClientData, void* theClientData,
void* theCallData ) void* /*theCallData*/ )
{ {
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) { if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) { if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {

2
src/SMESHGUI/SMESHGUI.h
View File

@ -202,7 +202,7 @@ protected:
static void ProcessEvents( vtkObject* theObject, static void ProcessEvents( vtkObject* theObject,
unsigned long theEvent, unsigned long theEvent,
void* theClientData, void* theClientData,
void* theCallData ); void* /*theCallData*/ );
private: private:
void OnEditDelete(); void OnEditDelete();

4
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

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

4
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

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

6
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -2175,8 +2175,8 @@ void SMESHGUI_TreeElemInfo::information( const QList<uint>& ids )
\param nbNodes number of unique nodes in element \param nbNodes number of unique nodes in element
\param parentItem parent item of tree \param parentItem parent item of tree
*/ */
void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index, void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* /*node*/, int /*index*/,
int nbNodes, QTreeWidgetItem* parentItem ) int /*nbNodes*/, QTreeWidgetItem* /*parentItem*/ )
{ {
// int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 ); // int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
// // node number and ID // // node number and ID
@ -2284,7 +2284,7 @@ void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
} }
} }
void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn ) void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int /*theColumn*/ )
{ {
if ( theItem ) { if ( theItem ) {
int type = theItem->data( 1, TypeRole ).toInt(); int type = theItem->data( 1, TypeRole ).toInt();

2
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

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

2
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -222,6 +222,6 @@ SMESHGUI_EXPORT
SMESHGUI_EXPORT SMESHGUI_EXPORT
void UpdateActorsAfterUpdateStudy(); void UpdateActorsAfterUpdateStudy();
}; }
#endif // SMESHGUI_VTKUTILS_H #endif // SMESHGUI_VTKUTILS_H

4
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -1230,7 +1230,7 @@ void _pyGen::Flush()
*/ */
//================================================================================ //================================================================================
void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const
{ {
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin(); // map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj ) // for ( ; id_obj != myObjects.end(); ++id_obj )
@ -4482,7 +4482,7 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd, bool toKeepAgrC
*/ */
//================================================================================ //================================================================================
bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName) bool _pySubMesh::CanBeArgOfMethod(const _AString& /*theMethodName*/)
{ {
return false; return false;
// names of all methods where a sub-mesh can be used as argument // names of all methods where a sub-mesh can be used as argument

6
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -260,7 +260,7 @@ public:
void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd ); void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
Handle(_pyCommand)& GetLastCommand(); Handle(_pyCommand)& GetLastCommand();
std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; } std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const; void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const;
_pyID GenerateNewID( const _pyID& theID ); _pyID GenerateNewID( const _pyID& theID );
bool AddObject( Handle(_pyObject)& theObj ); bool AddObject( Handle(_pyObject)& theObj );
@ -490,7 +490,7 @@ public:
virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd, virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
const _pyID& theMesh); const _pyID& theMesh);
virtual const char* AccessorMethod() const { return "GetAlgorithm()"; } virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; } virtual bool IsWrappable(const _pyID& /*theMesh*/) { return !myIsWrapped; }
DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis) DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis)
}; };
@ -600,7 +600,7 @@ public:
virtual Handle(_pyMesh) GetMesh() { return myMesh; } virtual Handle(_pyMesh) GetMesh() { return myMesh; }
virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); } virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; } void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
static bool CanBeArgOfMethod(const _AString& theMethodName); static bool CanBeArgOfMethod(const _AString& /*theMethodName*/);
DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject) DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
}; };

8
src/SMESH_I/SMESH_Algo_i.cxx
View File

@ -88,8 +88,8 @@ SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
*/ */
//================================================================================ //================================================================================
bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray, bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) const std::vector< int > & /*subIDArray*/ ) const
{ {
return false; return false;
} }
@ -100,8 +100,8 @@ bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray,
*/ */
//================================================================================ //================================================================================
bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & entryArray, bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) std::vector< int > & /*subIDArray*/ )
{ {
return true; return true;
} }

8
src/SMESH_I/SMESH_Algo_i.hxx
View File

@ -56,12 +56,12 @@ public:
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray, virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) const; std::vector< int > & /*subIDArray*/ ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray, virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ); std::vector< int > & /*subIDArray*/ );
}; };
#endif #endif

10
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -718,7 +718,7 @@ BadOrientedVolume_i::BadOrientedVolume_i()
{ {
Controls::PredicatePtr control( new Controls::BadOrientedVolume() ); Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
myFunctorPtr = myPredicatePtr = control; myFunctorPtr = myPredicatePtr = control;
}; }
FunctorType BadOrientedVolume_i::GetFunctorType() FunctorType BadOrientedVolume_i::GetFunctorType()
{ {
@ -733,7 +733,7 @@ BareBorderVolume_i::BareBorderVolume_i()
{ {
Controls::PredicatePtr control( new Controls::BareBorderVolume() ); Controls::PredicatePtr control( new Controls::BareBorderVolume() );
myFunctorPtr = myPredicatePtr = control; myFunctorPtr = myPredicatePtr = control;
}; }
FunctorType BareBorderVolume_i::GetFunctorType() FunctorType BareBorderVolume_i::GetFunctorType()
{ {
@ -748,7 +748,7 @@ BareBorderFace_i::BareBorderFace_i()
{ {
Controls::PredicatePtr control( new Controls::BareBorderFace() ); Controls::PredicatePtr control( new Controls::BareBorderFace() );
myFunctorPtr = myPredicatePtr = control; myFunctorPtr = myPredicatePtr = control;
}; }
FunctorType BareBorderFace_i::GetFunctorType() FunctorType BareBorderFace_i::GetFunctorType()
{ {
@ -763,7 +763,7 @@ OverConstrainedVolume_i::OverConstrainedVolume_i()
{ {
Controls::PredicatePtr control( new Controls::OverConstrainedVolume() ); Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
myFunctorPtr = myPredicatePtr = control; myFunctorPtr = myPredicatePtr = control;
}; }
FunctorType OverConstrainedVolume_i::GetFunctorType() FunctorType OverConstrainedVolume_i::GetFunctorType()
{ {
@ -778,7 +778,7 @@ OverConstrainedFace_i::OverConstrainedFace_i()
{ {
Controls::PredicatePtr control( new Controls::OverConstrainedFace() ); Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
myFunctorPtr = myPredicatePtr = control; myFunctorPtr = myPredicatePtr = control;
}; }
FunctorType OverConstrainedFace_i::GetFunctorType() FunctorType OverConstrainedFace_i::GetFunctorType()
{ {

2
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -55,7 +55,7 @@ namespace SMESH
*/ */
struct NotifyerAndWaiter struct NotifyerAndWaiter
{ {
virtual void OnBaseObjModified(NotifyerAndWaiter* obj, bool removed) {}; virtual void OnBaseObjModified(NotifyerAndWaiter* /*obj*/, bool /*removed*/) {};
// specific reaction on modification of a base object // specific reaction on modification of a base object
void Modified( bool removed=false, NotifyerAndWaiter* who = 0); void Modified( bool removed=false, NotifyerAndWaiter* who = 0);

2
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -1071,7 +1071,7 @@ SMESH_GroupOnFilter_i::~SMESH_GroupOnFilter_i()
*/ */
//================================================================================ //================================================================================
void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* filter, bool /*removed*/) void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool /*removed*/)
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile(); myPreMeshInfo->FullLoadFromFile();

2
src/SMESH_I/SMESH_Group_i.hxx
View File

@ -206,7 +206,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
virtual bool IsMeshInfoCorrect(); virtual bool IsMeshInfoCorrect();
// method of SMESH::NotifyerAndWaiter to update self when myFilter changes // method of SMESH::NotifyerAndWaiter to update self when myFilter changes
virtual void OnBaseObjModified(NotifyerAndWaiter* filter, bool); virtual void OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool);
private: private:
SMESH::Filter_var myFilter; SMESH::Filter_var myFilter;

10
src/SMESH_I/SMESH_Hypothesis_i.cxx
View File

@ -50,7 +50,7 @@ SMESH_Hypothesis_i::SMESH_Hypothesis_i( PortableServer::POA_ptr thePOA )
: SALOME::GenericObj_i( thePOA ) : SALOME::GenericObj_i( thePOA )
{ {
myBaseImpl = 0; myBaseImpl = 0;
}; }
//============================================================================= //=============================================================================
/*! /*!
@ -65,7 +65,7 @@ SMESH_Hypothesis_i::~SMESH_Hypothesis_i()
//MESSAGE( "SMESH_Hypothesis_i::~SMESH_Hypothesis_i" ); //MESSAGE( "SMESH_Hypothesis_i::~SMESH_Hypothesis_i" );
if ( myBaseImpl ) if ( myBaseImpl )
delete myBaseImpl; delete myBaseImpl;
}; }
//============================================================================= //=============================================================================
/*! /*!
@ -78,7 +78,7 @@ SMESH_Hypothesis_i::~SMESH_Hypothesis_i()
char* SMESH_Hypothesis_i::GetName() char* SMESH_Hypothesis_i::GetName()
{ {
return CORBA::string_dup( myBaseImpl->GetName() ); return CORBA::string_dup( myBaseImpl->GetName() );
}; }
//============================================================================= //=============================================================================
/*! /*!
@ -91,7 +91,7 @@ char* SMESH_Hypothesis_i::GetName()
char* SMESH_Hypothesis_i::GetLibName() char* SMESH_Hypothesis_i::GetLibName()
{ {
return CORBA::string_dup( myBaseImpl->GetLibName() ); return CORBA::string_dup( myBaseImpl->GetLibName() );
}; }
//============================================================================= //=============================================================================
/*! /*!
@ -104,7 +104,7 @@ char* SMESH_Hypothesis_i::GetLibName()
void SMESH_Hypothesis_i::SetLibName(const char* theLibName) void SMESH_Hypothesis_i::SetLibName(const char* theLibName)
{ {
myBaseImpl->SetLibName( theLibName ); myBaseImpl->SetLibName( theLibName );
}; }
//============================================================================= //=============================================================================
/*! /*!

6
src/SMESH_I/SMESH_Hypothesis_i.hxx
View File

@ -131,10 +131,10 @@ public:
// method used to convert variable parameters stored in an old study // method used to convert variable parameters stored in an old study
// into myMethod2VarParams. It should return a method name for an index of // into myMethod2VarParams. It should return a method name for an index of
// variable parameters. Index is countered from zero // variable parameters. Index is countered from zero
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const { return ""; } virtual std::string getMethodOfParameter(const int /*paramIndex*/, int /*nbVars*/) const { return ""; }
// method intended to remove explicit treatment of Netgen hypotheses from SMESH_NoteBook // method intended to remove explicit treatment of Netgen hypotheses from SMESH_NoteBook
virtual int getParamIndex(const TCollection_AsciiString& method, int nbVars) const { return -1; } virtual int getParamIndex(const TCollection_AsciiString& /*method*/, int /*nbVars*/) const { return -1; }
}; };
// ====================================================== // ======================================================
@ -152,7 +152,7 @@ public:
virtual std::string GetModuleName() = 0; virtual std::string GetModuleName() = 0;
// Check if an algorithm is applicable to a shape // Check if an algorithm is applicable to a shape
virtual bool IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim ) virtual bool IsApplicable( const TopoDS_Shape &S, bool /*toCheckAll*/, int algoDim )
{ {
return IsShapeOfDim( S, algoDim ); return IsShapeOfDim( S, algoDim );
} }

12
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -1692,25 +1692,25 @@ SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
{ {
bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/,
bool & toStopChecking ) bool & toStopChecking )
{ {
toStopChecking = ( nbCommon < nbChecked ); toStopChecking = ( nbCommon < nbChecked );
return nbCommon == nbNodes; return nbCommon == nbNodes;
} }
bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners,
bool & toStopChecking ) bool & toStopChecking )
{ {
toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners ); toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
return nbCommon == nbCorners; return nbCommon == nbCorners;
} }
bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/,
bool & toStopChecking ) bool & /*toStopChecking*/ )
{ {
return nbCommon > 0; return nbCommon > 0;
} }
bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners, bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/,
bool & toStopChecking ) bool & /*toStopChecking*/ )
{ {
return nbCommon >= (nbNodes+1) / 2; return nbCommon >= (nbNodes+1) / 2;
} }

4
src/SMESH_I/SMESH_PreMeshInfo.cxx
View File

@ -72,7 +72,7 @@ namespace
*/ */
//================================================================================ //================================================================================
void meshInfoLoaded( SMESH_Mesh_i* mesh ) void meshInfoLoaded( SMESH_Mesh_i* /*mesh*/ )
{ {
theMeshCounter++; theMeshCounter++;
} }
@ -82,7 +82,7 @@ namespace
*/ */
//================================================================================ //================================================================================
void filesNoMoreNeeded(SMESH_Mesh_i* mesh, void filesNoMoreNeeded(SMESH_Mesh_i* /*mesh*/,
std::string medFile, std::string medFile,
std::string hdfFile) std::string hdfFile)
{ {

16
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
View File

@ -191,10 +191,10 @@ namespace
bool _hasInternalFaces; bool _hasInternalFaces;
public: public:
virtual ~Solid() {} virtual ~Solid() {}
virtual bool Contains( TGeomID subID ) const { return true; } virtual bool Contains( TGeomID /*subID*/ ) const { return true; }
virtual bool ContainsAny( const vector< TGeomID>& subIDs ) const { return true; } virtual bool ContainsAny( const vector< TGeomID>& /*subIDs*/ ) const { return true; }
virtual TopAbs_Orientation Orientation( const TopoDS_Shape& s ) const { return s.Orientation(); } virtual TopAbs_Orientation Orientation( const TopoDS_Shape& s ) const { return s.Orientation(); }
virtual bool IsOutsideOriented( TGeomID faceID ) const { return true; } virtual bool IsOutsideOriented( TGeomID /*faceID*/ ) const { return true; }
void SetID( TGeomID id ) { _id = id; } void SetID( TGeomID id ) { _id = id; }
TGeomID ID() const { return _id; } TGeomID ID() const { return _id; }
void SetHasInternalFaces( bool has ) { _hasInternalFaces = has; } void SetHasInternalFaces( bool has ) { _hasInternalFaces = has; }
@ -5830,9 +5830,9 @@ bool StdMeshers_Cartesian_3D::Compute(SMESH_Mesh & theMesh,
*/ */
//============================================================================= //=============================================================================
bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & theMesh, bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & /*theMesh*/,
const TopoDS_Shape & theShape, const TopoDS_Shape & /*theShape*/,
MapShapeNbElems& theResMap) MapShapeNbElems& /*theResMap*/)
{ {
// TODO // TODO
// std::vector<int> aResVec(SMDSEntity_Last); // std::vector<int> aResVec(SMDSEntity_Last);
@ -5886,10 +5886,10 @@ namespace
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
// unsetting _alwaysComputed flag if "Cartesian_3D" was removed // unsetting _alwaysComputed flag if "Cartesian_3D" was removed
// //
virtual void ProcessEvent(const int event, virtual void ProcessEvent(const int /*event*/,
const int eventType, const int eventType,
SMESH_subMesh* subMeshOfSolid, SMESH_subMesh* subMeshOfSolid,
SMESH_subMeshEventListenerData* data, SMESH_subMeshEventListenerData* /*data*/,
const SMESH_Hypothesis* hyp = 0) const SMESH_Hypothesis* hyp = 0)
{ {
if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) if ( eventType == SMESH_subMesh::COMPUTE_EVENT )

4
src/StdMeshers/StdMeshers_Cartesian_3D.hxx
View File

@ -51,8 +51,8 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape); virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, virtual bool Evaluate(SMESH_Mesh & /*aMesh*/, const TopoDS_Shape & /*aShape*/,
MapShapeNbElems& aResMap); MapShapeNbElems& /*aResMap*/);
virtual void SetEventListener(SMESH_subMesh* subMesh); virtual void SetEventListener(SMESH_subMesh* subMesh);

4
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -283,8 +283,8 @@ StdMeshers_CompositeHexa_3D::StdMeshers_CompositeHexa_3D(int hypId, SMESH_Gen* g
*/ */
//================================================================================ //================================================================================
bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& aMesh, bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
const TopoDS_Shape& aShape, const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus) Hypothesis_Status& aStatus)
{ {
aStatus = HYP_OK; aStatus = HYP_OK;

4
src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
View File

@ -52,8 +52,8 @@ public:
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap); MapShapeNbElems& aResMap);
virtual bool CheckHypothesis(SMESH_Mesh& aMesh, virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
const TopoDS_Shape& aShape, const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus); Hypothesis_Status& aStatus);
private: private:

2
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -869,7 +869,7 @@ bool StdMeshers_Hexa_3D::IsApplicable( const TopoDS_Shape & aShape, bool toCheck
if ( !toCheckAll && ok ) return true; if ( !toCheckAll && ok ) return true;
} }
return toCheckAll; return toCheckAll;
}; }
//======================================================================= //=======================================================================
//function : ComputePentahedralMesh //function : ComputePentahedralMesh

2
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -677,7 +677,7 @@ bool StdMeshers_MEFISTO_2D::LoadPoints(TWireVector & wires,
*/ */
//============================================================================= //=============================================================================
void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh, void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & /*aMesh*/,
const TopoDS_Face & aFace, const TopoDS_Face & aFace,
double & scalex, double & scalex,
double & scaley) double & scaley)

2
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
View File

@ -68,7 +68,7 @@ public:
std::vector< const SMDS_MeshNode*>& mefistoToDS, std::vector< const SMDS_MeshNode*>& mefistoToDS,
double scalex, double scaley); double scalex, double scaley);
void ComputeScaleOnFace(SMESH_Mesh& aMesh, void ComputeScaleOnFace(SMESH_Mesh& /*aMesh*/,
const TopoDS_Face& aFace, const TopoDS_Face& aFace,
double& scalex, double& scalex,
double& scaley); double& scaley);

4
src/StdMeshers/StdMeshers_NotConformAllowed.cxx
View File

@ -81,7 +81,7 @@ istream & StdMeshers_NotConformAllowed::LoadFrom(istream & load)
*/ */
//============================================================================= //=============================================================================
ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp) ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & /*hyp*/)
{ {
return save; return save;
} }
@ -92,7 +92,7 @@ ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
*/ */
//============================================================================= //=============================================================================
istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp) istream & operator >> (istream & load, StdMeshers_NotConformAllowed & /*hyp*/)
{ {
return load; return load;
} }

4
src/StdMeshers/StdMeshers_NotConformAllowed.hxx
View File

@ -42,8 +42,8 @@ public:
virtual std::ostream & SaveTo(std::ostream & save); virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load); virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & hyp); friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & /*hyp*/);
friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & hyp); friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & /*hyp*/);
/*! /*!
* \brief Initialize my parameter values by the mesh built on the geometry * \brief Initialize my parameter values by the mesh built on the geometry

4
src/StdMeshers/StdMeshers_PolygonPerFace_2D.cxx
View File

@ -60,8 +60,8 @@ StdMeshers_PolygonPerFace_2D::StdMeshers_PolygonPerFace_2D(int hypId,
//purpose : //purpose :
//======================================================================= //=======================================================================
bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& theMesh, bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& /*theMesh*/,
const TopoDS_Shape& theShape, const TopoDS_Shape& /*theShape*/,
SMESH_Hypothesis::Hypothesis_Status& theStatus) SMESH_Hypothesis::Hypothesis_Status& theStatus)
{ {
theStatus = HYP_OK; theStatus = HYP_OK;

4
src/StdMeshers/StdMeshers_PolygonPerFace_2D.hxx
View File

@ -34,8 +34,8 @@ class STDMESHERS_EXPORT StdMeshers_PolygonPerFace_2D: public SMESH_2D_Algo
public: public:
StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen); StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen);
virtual bool CheckHypothesis(SMESH_Mesh& aMesh, virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
const TopoDS_Shape& aShape, const TopoDS_Shape& /*aShape*/,
SMESH_Hypothesis::Hypothesis_Status& aStatus); SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape); virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);

6
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -450,7 +450,7 @@ namespace {
//================================================================================ //================================================================================
int countNbSides( const Prism_3D::TPrismTopo & thePrism, int countNbSides( const Prism_3D::TPrismTopo & thePrism,
vector<int> & nbUnitePerEdge, vector<int> & /*nbUnitePerEdge*/,
vector< double > & edgeLength) vector< double > & edgeLength)
{ {
int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges
@ -598,8 +598,8 @@ StdMeshers_Prism_3D::~StdMeshers_Prism_3D()
//purpose : //purpose :
//======================================================================= //=======================================================================
bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& aMesh, bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
const TopoDS_Shape& aShape, const TopoDS_Shape& /*aShape*/,
SMESH_Hypothesis::Hypothesis_Status& aStatus) SMESH_Hypothesis::Hypothesis_Status& aStatus)
{ {
// no hypothesis // no hypothesis

4
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -482,8 +482,8 @@ public:
StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen); StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Prism_3D(); virtual ~StdMeshers_Prism_3D();
virtual bool CheckHypothesis(SMESH_Mesh& aMesh, virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
const TopoDS_Shape& aShape, const TopoDS_Shape& /*aShape*/,
SMESH_Hypothesis::Hypothesis_Status& aStatus); SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape); virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);

2
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -336,6 +336,6 @@ namespace StdMeshers_ProjectionUtils
TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape& edgeContainer, TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape& edgeContainer,
const SMESH_Mesh& mesh, const SMESH_Mesh& mesh,
std::list< TopoDS_Edge >* allBndEdges = 0 ); std::list< TopoDS_Edge >* allBndEdges = 0 );
}; }
#endif #endif

16
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -278,7 +278,7 @@ namespace {
//================================================================================ //================================================================================
bool getBoundaryNodes ( SMESH_subMesh* sm, bool getBoundaryNodes ( SMESH_subMesh* sm,
const TopoDS_Face& face, const TopoDS_Face& /*face*/,
map< double, const SMDS_MeshNode* > & u2nodes, map< double, const SMDS_MeshNode* > & u2nodes,
set< const SMDS_MeshNode* > & seamNodes) set< const SMDS_MeshNode* > & seamNodes)
{ {
@ -975,13 +975,13 @@ namespace {
*/ */
//================================================================================ //================================================================================
bool projectQuads(const TopoDS_Face& tgtFace, bool projectQuads(const TopoDS_Face& /*tgtFace*/,
const TopoDS_Face& srcFace, const TopoDS_Face& /*srcFace*/,
const TSideVector& tgtWires, const TSideVector& /*tgtWires*/,
const TSideVector& srcWires, const TSideVector& /*srcWires*/,
const TAssocTool::TShapeShapeMap& shape2ShapeMap, const TAssocTool::TShapeShapeMap& /*shape2ShapeMap*/,
TAssocTool::TNodeNodeMap& src2tgtNodes, TAssocTool::TNodeNodeMap& /*src2tgtNodes*/,
const bool is1DComputed) const bool /*is1DComputed*/)
{ {
// SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh(); // SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh();
// SMESH_Mesh * srcMesh = srcWires[0]->GetMesh(); // SMESH_Mesh * srcMesh = srcWires[0]->GetMesh();

8
src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
View File

@ -260,8 +260,8 @@ namespace
virtual void ProcessEvent(const int event, virtual void ProcessEvent(const int event,
const int eventType, const int eventType,
SMESH_subMesh* faceSubMesh, SMESH_subMesh* faceSubMesh,
SMESH_subMeshEventListenerData* data, SMESH_subMeshEventListenerData* /*data*/,
const SMESH_Hypothesis* hyp) const SMESH_Hypothesis* /*hyp*/)
{ {
if ( eventType == SMESH_subMesh::ALGO_EVENT ) if ( eventType == SMESH_subMesh::ALGO_EVENT )
{ {
@ -1248,7 +1248,7 @@ namespace
//================================================================================ //================================================================================
void separateNodes( SMESH_MesherHelper& theHelper, void separateNodes( SMESH_MesherHelper& theHelper,
const SMESH_MAT2d::MedialAxis& theMA, const SMESH_MAT2d::MedialAxis& /*theMA*/,
TMAPar2NPoints & thePointsOnE, TMAPar2NPoints & thePointsOnE,
SinuousFace& theSinuFace, SinuousFace& theSinuFace,
const vector< bool >& theIsComputedEdge) const vector< bool >& theIsComputedEdge)
@ -1932,7 +1932,7 @@ namespace
const vector<TopoDS_Edge>& theShortEdges, const vector<TopoDS_Edge>& theShortEdges,
SMESH_Algo* the1dAlgo, SMESH_Algo* the1dAlgo,
const bool theHasRadialHyp, const bool theHasRadialHyp,
const bool theIs2nd) const bool /*theIs2nd*/)
{ {
SMESH_Hypothesis::Hypothesis_Status aStatus; SMESH_Hypothesis::Hypothesis_Status aStatus;
for ( size_t i = 0; i < theShortEdges.size(); ++i ) for ( size_t i = 0; i < theShortEdges.size(); ++i )

4
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -3208,8 +3208,8 @@ bool StdMeshers_Quadrangle_2D::evaluateQuadPref(SMESH_Mesh & aMesh,
*/ */
//============================================================================= //=============================================================================
void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * theMeshDS, void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/,
int theFaceID, int /*theFaceID*/,
const SMDS_MeshNode* theNode1, const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2, const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3, const SMDS_MeshNode* theNode3,

4
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -174,8 +174,8 @@ class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
bool setNormalizedGrid(FaceQuadStruct::Ptr quad); bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
void splitQuadFace(SMESHDS_Mesh * theMeshDS, void splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/,
const int theFaceID, const int /*theFaceID*/,
const SMDS_MeshNode* theNode1, const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2, const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3, const SMDS_MeshNode* theNode3,

2
src/StdMeshers/StdMeshers_RadialPrism_3D.cxx
View File

@ -636,4 +636,4 @@ bool StdMeshers_RadialPrism_3D::IsApplicable( const TopoDS_Shape & aShape, bool
if ( !toCheckAll ) return true; if ( !toCheckAll ) return true;
} }
return ( toCheckAll && nbFoundSolids != 0); return ( toCheckAll && nbFoundSolids != 0);
}; }

12
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
View File

@ -164,9 +164,9 @@ namespace
return &theEdgeMarker; return &theEdgeMarker;
} }
//! Clear edge sumbesh if something happens on face //! Clear edge sumbesh if something happens on face
void ProcessEvent(const int event, void ProcessEvent(const int /*event*/,
const int eventType, const int eventType,
SMESH_subMesh* faceSubMesh, SMESH_subMesh* /*faceSubMesh*/,
EventListenerData* edgesHolder, EventListenerData* edgesHolder,
const SMESH_Hypothesis* /*hyp*/) const SMESH_Hypothesis* /*hyp*/)
{ {
@ -402,9 +402,9 @@ namespace
*/ */
//================================================================================ //================================================================================
bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& CircSide, bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& /*CircSide*/,
const StdMeshers_FaceSidePtr& LinSide1, const StdMeshers_FaceSidePtr& /*LinSide1*/,
const StdMeshers_FaceSidePtr& LinSide2) const StdMeshers_FaceSidePtr& /*LinSide2*/)
{ {
// if ( CircSide && LinSide1 && LinSide2 ) // if ( CircSide && LinSide1 && LinSide2 )
// { // {
@ -1279,4 +1279,4 @@ bool StdMeshers_RadialQuadrangle_1D2D::IsApplicable( const TopoDS_Shape & aShape
} }
if( toCheckAll && nbFoundFaces != 0 ) return true; if( toCheckAll && nbFoundFaces != 0 ) return true;
return false; return false;
}; }

52
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

@ -206,8 +206,8 @@ namespace VISCOUS_3D
virtual void ProcessEvent(const int event, virtual void ProcessEvent(const int event,
const int eventType, const int eventType,
SMESH_subMesh* subMesh, SMESH_subMesh* subMesh,
SMESH_subMeshEventListenerData* data, SMESH_subMeshEventListenerData* /*data*/,
const SMESH_Hypothesis* hyp) const SMESH_Hypothesis* /*hyp*/)
{ {
if (( SMESH_subMesh::COMPUTE_EVENT == eventType ) && if (( SMESH_subMesh::COMPUTE_EVENT == eventType ) &&
( SMESH_subMesh::CHECK_COMPUTE_STATE != event && ( SMESH_subMesh::CHECK_COMPUTE_STATE != event &&
@ -440,7 +440,7 @@ namespace VISCOUS_3D
std::string DumpFlags() const; // debug std::string DumpFlags() const; // debug
void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper ); void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
bool SetNewLength2d( Handle(Geom_Surface)& surface, bool SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
const TopoDS_Face& F, const TopoDS_Face& F,
_EdgesOnShape& eos, _EdgesOnShape& eos,
SMESH_MesherHelper& helper ); SMESH_MesherHelper& helper );
@ -451,7 +451,7 @@ namespace VISCOUS_3D
void Block( _SolidData& data ); void Block( _SolidData& data );
void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false ); void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false );
void ChooseSmooFunction(const set< TGeomID >& concaveVertices, void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
const TNode2Edge& n2eMap); const TNode2Edge& /*n2eMap*/);
void SmoothPos( const vector< double >& segLen, const double tol ); void SmoothPos( const vector< double >& segLen, const double tol );
int GetSmoothedPos( const double tol ); int GetSmoothedPos( const double tol );
int Smooth(const int step, const bool isConcaveFace, bool findBest); int Smooth(const int step, const bool isConcaveFace, bool findBest);
@ -937,7 +937,7 @@ namespace VISCOUS_3D
bool shiftInside=false); bool shiftInside=false);
bool getFaceNormalAtSingularity(const gp_XY& uv, bool getFaceNormalAtSingularity(const gp_XY& uv,
const TopoDS_Face& face, const TopoDS_Face& face,
SMESH_MesherHelper& helper, SMESH_MesherHelper& /*helper*/,
gp_Dir& normal ); gp_Dir& normal );
gp_XYZ getWeigthedNormal( const _LayerEdge* edge ); gp_XYZ getWeigthedNormal( const _LayerEdge* edge );
gp_XYZ getNormalByOffset( _LayerEdge* edge, gp_XYZ getNormalByOffset( _LayerEdge* edge,
@ -975,15 +975,15 @@ namespace VISCOUS_3D
SMESH_MesherHelper& helper ); SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper ); void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2, void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2,
_EdgesOnShape& eos1, _EdgesOnShape& eos2, _EdgesOnShape& /*eos1*/, _EdgesOnShape& /*eos2*/,
const bool isSmoothable ); const bool /*isSmoothable*/ );
bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double stepSize ); bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double /*stepSize*/ );
bool updateNormalsOfConvexFaces( _SolidData& data, bool updateNormalsOfConvexFaces( _SolidData& data,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
int stepNb ); int stepNb );
void updateNormalsOfC1Vertices( _SolidData& data ); void updateNormalsOfC1Vertices( _SolidData& data );
bool updateNormalsOfSmoothed( _SolidData& data, bool updateNormalsOfSmoothed( _SolidData& data,
SMESH_MesherHelper& helper, SMESH_MesherHelper& /*helper*/,
const int nbSteps, const int nbSteps,
const double stepSize ); const double stepSize );
bool isNewNormalOk( _SolidData& data, bool isNewNormalOk( _SolidData& data,
@ -993,7 +993,7 @@ namespace VISCOUS_3D
bool shrink(_SolidData& data); bool shrink(_SolidData& data);
bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos, bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
const SMESHDS_SubMesh* faceSubMesh ); const SMESHDS_SubMesh* /*faceSubMesh*/ );
void restoreNoShrink( _LayerEdge& edge ) const; void restoreNoShrink( _LayerEdge& edge ) const;
void fixBadFaces(const TopoDS_Face& F, void fixBadFaces(const TopoDS_Face& F,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
@ -1091,10 +1091,10 @@ namespace VISCOUS_3D
Handle(ShapeAnalysis_Surface)& surface, Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
SMESH_MesherHelper& helper); SMESH_MesherHelper& helper);
bool smoothComplexEdge( _SolidData& data, bool smoothComplexEdge( _SolidData& /*data*/,
Handle(ShapeAnalysis_Surface)& surface, Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
SMESH_MesherHelper& helper); SMESH_MesherHelper& /*helper*/);
gp_XYZ getNormalNormal( const gp_XYZ & normal, gp_XYZ getNormalNormal( const gp_XYZ & normal,
const gp_XYZ& edgeDir); const gp_XYZ& edgeDir);
_LayerEdge* getLEdgeOnV( bool is2nd ) _LayerEdge* getLEdgeOnV( bool is2nd )
@ -1376,8 +1376,8 @@ std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
} }
return load; return load;
} // -------------------------------------------------------------------------------- } // --------------------------------------------------------------------------------
bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* theMesh, bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
const TopoDS_Shape& theShape) const TopoDS_Shape& /*theShape*/)
{ {
// TODO // TODO
return false; return false;
@ -3953,7 +3953,7 @@ gp_XYZ _ViscousBuilder::getFaceNormal(const SMDS_MeshNode* node,
bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY& uv, bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY& uv,
const TopoDS_Face& face, const TopoDS_Face& face,
SMESH_MesherHelper& helper, SMESH_MesherHelper& /*helper*/,
gp_Dir& normal ) gp_Dir& normal )
{ {
BRepAdaptor_Surface surface( face ); BRepAdaptor_Surface surface( face );
@ -6086,10 +6086,10 @@ bool _Smoother1D::smoothAnalyticEdge( _SolidData& data,
*/ */
//================================================================================ //================================================================================
bool _Smoother1D::smoothComplexEdge( _SolidData& data, bool _Smoother1D::smoothComplexEdge( _SolidData& /*data*/,
Handle(ShapeAnalysis_Surface)& surface, Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
SMESH_MesherHelper& helper) SMESH_MesherHelper& /*helper*/)
{ {
if ( _offPoints.empty() ) if ( _offPoints.empty() )
return false; return false;
@ -6746,7 +6746,7 @@ void _SolidData::AddShapesToSmooth( const set< _EdgesOnShape* >& eosToSmooth,
*/ */
//================================================================================ //================================================================================
void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper ) void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& /*helper*/ )
{ {
// find intersection of neighbor _LayerEdge's to limit _maxLen // find intersection of neighbor _LayerEdge's to limit _maxLen
// according to local curvature (IPAL52648) // according to local curvature (IPAL52648)
@ -6798,9 +6798,9 @@ void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelp
void _ViscousBuilder::limitMaxLenByCurvature( _LayerEdge* e1, void _ViscousBuilder::limitMaxLenByCurvature( _LayerEdge* e1,
_LayerEdge* e2, _LayerEdge* e2,
_EdgesOnShape& eos1, _EdgesOnShape& /*eos1*/,
_EdgesOnShape& eos2, _EdgesOnShape& /*eos2*/,
const bool isSmoothable ) const bool /*isSmoothable*/ )
{ {
if (( e1->_nodes[0]->GetPosition()->GetDim() != if (( e1->_nodes[0]->GetPosition()->GetDim() !=
e2->_nodes[0]->GetPosition()->GetDim() ) && e2->_nodes[0]->GetPosition()->GetDim() ) &&
@ -7119,7 +7119,7 @@ void _ViscousBuilder::findEdgesToUpdateNormalNearConvexFace( _ConvexFace &
bool _ViscousBuilder::updateNormals( _SolidData& data, bool _ViscousBuilder::updateNormals( _SolidData& data,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
int stepNb, int stepNb,
double stepSize) double /*stepSize*/)
{ {
updateNormalsOfC1Vertices( data ); updateNormalsOfC1Vertices( data );
@ -7459,7 +7459,7 @@ bool _ViscousBuilder::isNewNormalOk( _SolidData& data,
//================================================================================ //================================================================================
bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData& data, bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData& data,
SMESH_MesherHelper& helper, SMESH_MesherHelper& /*helper*/,
const int nbSteps, const int nbSteps,
const double stepSize ) const double stepSize )
{ {
@ -8917,7 +8917,7 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, bool findBest )
//================================================================================ //================================================================================
void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices, void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
const TNode2Edge& n2eMap) const TNode2Edge& /*n2eMap*/)
{ {
if ( _smooFunction ) return; if ( _smooFunction ) return;
@ -11512,7 +11512,7 @@ bool _ViscousBuilder::shrink(_SolidData& theData)
bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge& edge, bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge& edge,
_EdgesOnShape& eos, _EdgesOnShape& eos,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
const SMESHDS_SubMesh* faceSubMesh) const SMESHDS_SubMesh* /*faceSubMesh*/)
{ {
const SMDS_MeshNode* srcNode = edge._nodes[0]; const SMDS_MeshNode* srcNode = edge._nodes[0];
const SMDS_MeshNode* tgtNode = edge._nodes.back(); const SMDS_MeshNode* tgtNode = edge._nodes.back();
@ -11801,7 +11801,7 @@ void _ViscousBuilder::fixBadFaces(const TopoDS_Face& F,
*/ */
//================================================================================ //================================================================================
bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& surface, bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
const TopoDS_Face& F, const TopoDS_Face& F,
_EdgesOnShape& eos, _EdgesOnShape& eos,
SMESH_MesherHelper& helper ) SMESH_MesherHelper& helper )

4
src/StdMeshers/StdMeshers_ViscousLayers.hxx
View File

@ -106,13 +106,13 @@ public:
* \param theShape - the geometry of interest * \param theShape - the geometry of interest
* \retval bool - true if parameter values have been successfully defined * \retval bool - true if parameter values have been successfully defined
*/ */
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape); virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
/*! /*!
* \brief Initialize my parameter values by default parameters. * \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined * \retval bool - true if parameter values have been successfully defined
*/ */
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0) virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* theMesh=0)
{ return false; } { return false; }
static const char* GetHypType() { return "ViscousLayers"; } static const char* GetHypType() { return "ViscousLayers"; }

4
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
View File

@ -509,8 +509,8 @@ StdMeshers_ViscousLayers2D::StdMeshers_ViscousLayers2D(int hypId, SMESH_Gen* gen
_param_algo_dim = -2; // auxiliary hyp used by 2D algos _param_algo_dim = -2; // auxiliary hyp used by 2D algos
} }
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* theMesh, bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
const TopoDS_Shape& theShape) const TopoDS_Shape& /*theShape*/)
{ {
// TODO ??? // TODO ???
return false; return false;

4
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
View File

@ -62,13 +62,13 @@ public:
* *
* Just return false as this hypothesis does not have parameters values * Just return false as this hypothesis does not have parameters values
*/ */
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape); virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
/*! /*!
* \brief Initialize my parameter values by default parameters. * \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined * \retval bool - true if parameter values have been successfully defined
*/ */
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0) virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* theMesh=0)
{ return false; } { return false; }
static const char* GetHypType() { return "ViscousLayers2D"; } static const char* GetHypType() { return "ViscousLayers2D"; }

8
src/StdMeshers_I/StdMeshers_Adaptive1D_i.hxx
View File

@ -85,10 +85,10 @@ class STDMESHERS_I_EXPORT StdMeshers_Adaptive1D_i:
CORBA::Boolean IsDimSupported( SMESH::Dimension type ); CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry // Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray, virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) const { return false; } std::vector< int > & /*subIDArray*/ ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray, virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) { return true; } std::vector< int > & /*subIDArray*/ ) { return true; }
}; };
#endif #endif

6
src/Tools/MeshCut/MeshCut_Maillage.cxx
View File

@ -78,7 +78,7 @@ void Maillage::afficheMailles(TYPE_MAILLE tm)
} }
} }
void Maillage::listeMaillesType(TYPE_MAILLE tm) void Maillage::listeMaillesType(TYPE_MAILLE /*tm*/)
{ {
cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl; cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
@ -854,7 +854,7 @@ void Maillage::inputMED(std::string fichierMED)
} }
void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1],
med_int mdim) med_int /*mdim*/)
{ {
// int taille, numeromaille, numeroFamille; // int taille, numeromaille, numeroFamille;
@ -1595,7 +1595,7 @@ TYPE_MAILLE Maillage::TYPE(int nglobal)
return resultat; return resultat;
} }
int Maillage::NLOCAL(int nglobal, TYPE_MAILLE tm) int Maillage::NLOCAL(int nglobal, TYPE_MAILLE /*tm*/)
{ {
// Attention, les num. globaux commencent à 1, les num. locaux à 0 // Attention, les num. globaux commencent à 1, les num. locaux à 0
int nPOI1 = EFFECTIFS_TYPES[POI1]; int nPOI1 = EFFECTIFS_TYPES[POI1];

6
src/Tools/MeshCut/MeshCut_Maillage.hxx
View File

@ -95,7 +95,7 @@ namespace MESHCUT
void creationGMtype(TYPE_MAILLE tm, std::string nomGMtype); void creationGMtype(TYPE_MAILLE tm, std::string nomGMtype);
void afficheMailles(TYPE_MAILLE tm); void afficheMailles(TYPE_MAILLE tm);
void listeMaillesType(TYPE_MAILLE tm); void listeMaillesType(TYPE_MAILLE /*tm*/);
void listeMaillesTousTypes(); void listeMaillesTousTypes();
void listeMaillesParGM(); void listeMaillesParGM();
void listeMaillesGM(std::string nomGM); void listeMaillesGM(std::string nomGM);
@ -120,13 +120,13 @@ namespace MESHCUT
// std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence); // std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence);
// void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE); // void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE);
int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal); int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal);
int NLOCAL(int nglobal, TYPE_MAILLE tm); int NLOCAL(int nglobal, TYPE_MAILLE /*tm*/);
TYPE_MAILLE TYPE(int nglobal); TYPE_MAILLE TYPE(int nglobal);
void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr); void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr);
// acquisitionTYPE_inputMED appelée par inputMED // acquisitionTYPE_inputMED appelée par inputMED
void void
acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int mdim); acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int /*mdim*/);
// void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa, // void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa,
// char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS); // char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS);