static void addElemInMeshGroup(SMESH_Mesh* theMesh,
const SMDS_MeshElement* anElem,
std::string& groupName,
- std::set<std::string>& groupsToRemove)
+ std::set<std::string>& /*groupsToRemove*/)
{
if ( !anElem ) return; // issue 0021776
SMESH_MesherHelper* theHelper,
std::vector <const SMDS_MeshNode*> & theNodeByGhs3dId,
std::vector <const SMDS_MeshElement*> & theFaceByGhs3dId,
- map<const SMDS_MeshNode*,int> & theNodeToGhs3dIdMap,
+ map<const SMDS_MeshNode*,int> & /*theNodeToGhs3dIdMap*/,
std::vector<std::string> & aNodeGroupByGhs3dId,
std::vector<std::string> & anEdgeGroupByGhs3dId,
std::vector<std::string> & aFaceGroupByGhs3dId,
std::vector< const SMDS_MeshElement* > foundVolumes;
if ( !hasGeom && theHelper->GetMesh()->NbVolumes() > 0 )
elemSearcher = SMESH_MeshAlgos::GetElementSearcher( *theMeshDS );
- auto_ptr< SMESH_ElementSearcher > elemSearcherDeleter( elemSearcher );
+ unique_ptr< SMESH_ElementSearcher > elemSearcherDeleter( elemSearcher ); //auto_ptr
// IMP 0022172: [CEA 790] create the groups corresponding to domains
std::vector< std::vector< const SMDS_MeshElement* > > elemsOfDomain;
*/
void ProcessEvent(const int event,
const int eventType,
- SMESH_subMesh* subMesh,
+ SMESH_subMesh* /*subMesh*/,
SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ const SMESH_Hypothesis* /*hyp*/)
{
if ( SMESH_subMesh::SUBMESH_LOADED == event &&
SMESH_subMesh::COMPUTE_EVENT == eventType &&
/*!
* \brief Treat events of the subMesh
*/
- void ProcessEvent(const int event,
+ void ProcessEvent(const int /*event*/,
const int eventType,
SMESH_subMesh* subMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if (SMESH_subMesh::ALGO_EVENT == eventType &&
!subMesh->GetAlgo() )
//=======================================================================
GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforcedVertex(double x, double y, double z)
- throw (std::invalid_argument)
{
std::vector<double> coord(3);
coord[0] = x;
}
GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforcedVertex(const std::string theEntry)
- throw (std::invalid_argument)
{
if (_geomEntryEnfVertexMap.count(theEntry)>0)
return _geomEntryEnfVertexMap[theEntry];
//=======================================================================
bool GHS3DPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z, const std::string theEntry)
- throw (std::invalid_argument)
{
bool toNotify = false;
std::ostringstream msg;
//=============================================================================
void GHS3DPlugin_Hypothesis::SetOptionValue(const std::string& optionName,
const std::string& optionValue)
- throw (std::invalid_argument)
{
TOptionValues::iterator op_val = _option2value.find(optionName);
if (op_val == _option2value.end())
// empty if it equals a default one.
std::string GHS3DPlugin_Hypothesis::GetOptionValue(const std::string& optionName,
bool* isDefault) const
- throw (std::invalid_argument)
{
TOptionValues::const_iterator op_val = _option2value.find(optionName);
if (op_val == _option2value.end())
{
GetOptionValue( optionName, &isDefault );
}
- catch ( std::invalid_argument )
+ catch ( std::invalid_argument& )
{
return false;
}
//================================================================================
bool GHS3DPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
- throw (std::invalid_argument)
{
std::string s = str;
if ( isOk ) *isOk = true;
//================================================================================
double GHS3DPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
- throw (std::invalid_argument)
{
if ( str.empty() ) throw std::invalid_argument("Empty value provided");
//================================================================================
int GHS3DPlugin_Hypothesis::ToInt(const std::string& str, bool* isOk )
- throw (std::invalid_argument)
{
if ( str.empty() ) throw std::invalid_argument("Empty value provided");
struct TIDMeshIDCompare {
bool operator () (const SMDS_MeshElement* e1, const SMDS_MeshElement* e2) const
- { return e1->GetMesh() == e2->GetMesh() ? e1->GetID() < e2->GetID() : e1->GetMesh() < e2->GetMesh() ; }
+ { return e1->GetMesh() == e2->GetMesh() ? e1->GetID() < e2->GetID() : e1->GetMesh() < e2->GetMesh(); }
};
typedef std::map<const SMDS_MeshElement*, std::string, TIDMeshIDCompare > TIDSortedElemGroupMap;
* To define the volumic gradation
*/
void SetGradation(double gradation);
- double GetGradation() const ;
+ double GetGradation() const;
/*!
* Print log in standard output
*/
void SetStandardOutputLog(bool logInStandardOutput);
- bool GetStandardOutputLog() const ;
+ bool GetStandardOutputLog() const;
/*!
* Remove log file on success
*/
void SetRemoveLogOnSuccess(bool removeLogOnSuccess);
- bool GetRemoveLogOnSuccess() const ;
+ bool GetRemoveLogOnSuccess() const;
typedef std::map< std::string, std::string > TOptionValues;
typedef std::set< std::string > TOptionNames;
void SetOptionValue(const std::string& optionName,
- const std::string& optionValue) throw (std::invalid_argument);
+ const std::string& optionValue);
std::string GetOptionValue(const std::string& optionName,
- bool* isDefault=0) const throw (std::invalid_argument);
+ bool* isDefault=0) const;
bool HasOptionDefined( const std::string& optionName ) const;
void ClearOption(const std::string& optionName);
TOptionValues GetOptionValues() const;
*/
bool SetEnforcedVertex(std::string aName, std::string anEntry, std::string aGroupName,
double size, double x=0.0, double y=0.0, double z=0.0, bool isCompound = false);
- TGHS3DEnforcedVertex* GetEnforcedVertex(double x, double y, double z) throw (std::invalid_argument);
- TGHS3DEnforcedVertex* GetEnforcedVertex(const std::string anEntry) throw (std::invalid_argument);
- bool RemoveEnforcedVertex(double x=0.0, double y=0.0, double z=0.0, const std::string anEntry="" ) throw (std::invalid_argument);
+ TGHS3DEnforcedVertex* GetEnforcedVertex(double x, double y, double z);
+ TGHS3DEnforcedVertex* GetEnforcedVertex(const std::string anEntry);
+ bool RemoveEnforcedVertex(double x=0.0, double y=0.0, double z=0.0, const std::string anEntry="" );
const TGHS3DEnforcedVertexCoordsValues& _GetEnforcedVerticesCoordsSize() const {return _enfVertexCoordsSizeList; }
const TGHS3DEnforcedVertexEntryValues & _GetEnforcedVerticesEntrySize() const {return _enfVertexEntrySizeList; }
const TGHS3DEnforcedVertexList & _GetEnforcedVertices() const { return _enfVertexList; }
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
- static bool ToBool(const std::string& str, bool* isOk=0) throw (std::invalid_argument);
- static double ToDbl(const std::string& str, bool* isOk=0) throw (std::invalid_argument);
- static int ToInt(const std::string& str, bool* isOk=0) throw (std::invalid_argument);
+ static bool ToBool(const std::string& str, bool* isOk=0);
+ static double ToDbl(const std::string& str, bool* isOk=0);
+ static int ToInt(const std::string& str, bool* isOk=0);
protected:
//=======================================================================
void GHS3DPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Float MB)
- throw ( SALOME::SALOME_Exception )
{
if ( MB == 0 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
//=======================================================================
void GHS3DPlugin_Hypothesis_i::SetInitialMemory(CORBA::Float MB)
- throw ( SALOME::SALOME_Exception )
{
if ( MB == 0 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
//=======================================================================
void GHS3DPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
- throw ( SALOME::SALOME_Exception )
{
::GHS3DPlugin_Hypothesis::OptimizationLevel l =
(::GHS3DPlugin_Hypothesis::OptimizationLevel) level;
//function : SetWorkingDirectory
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
+void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path)
{
if (!path )
THROW_SALOME_CORBA_EXCEPTION( "Null working directory",SALOME::BAD_PARAM );
//=======================================================================
void GHS3DPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
- throw ( SALOME::SALOME_Exception )
{
if (level < 0 || level > 10 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid verbose level, valid range is [0-10]",
//=============================================================================
void GHS3DPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
try {
try {
valueChanged = ( this->GetImpl()->GetOptionValue( name ) != optionValue );
}
- catch ( std::invalid_argument ) {
+ catch ( std::invalid_argument& ) {
}
if ( valueChanged )
{
//=============================================================================
char* GHS3DPlugin_Hypothesis_i::GetOptionValue(const char* optionName)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
try {
//=============================================================================
void GHS3DPlugin_Hypothesis_i::SetOptionValues(const GHS3DPlugin::string_array& options)
- throw (SALOME::SALOME_Exception)
{
for (CORBA::ULong i = 0; i < options.length(); ++i)
{
//=============================================================================
void GHS3DPlugin_Hypothesis_i::SetAdvancedOption(const char* optionsAndValues)
- throw (SALOME::SALOME_Exception)
{
if ( !optionsAndValues ) return;
//=======================================================================
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z);
}
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", "");
}
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z, "", "", theGroupName);
}
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", theGroupName);
}
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
}
bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::Double x, CORBA::Double y, CORBA::Double z,
const char* theVertexName, const char* theVertexEntry, const char* theGroupName,
CORBA::Boolean isCompound)
- throw (SALOME::SALOME_Exception) {
+{
ASSERT(myBaseImpl);
bool newValue = false;
//=======================================================================
CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
try {
//=======================================================================
CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
//=======================================================================
bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
try {
}
bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
* \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource. The elements will be grouped in theGroupName.
*/
bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
{
return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
}
* \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource.
*/
bool GHS3DPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType)
- throw (SALOME::SALOME_Exception)
{
return p_SetEnforcedMesh(theSource, theType);
}
/*!
* \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size. The elements will be grouped in theGroupName.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double /*theSize*/, const char* theGroupName)
{
return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
}
/*!
* \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize)
- throw (SALOME::SALOME_Exception)
+bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double /*theSize*/)
{
return p_SetEnforcedMesh(theSource, theType);
}
SMESH::ElementType theType,
const char* theName,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
bool
GHS3DPlugin_Hypothesis_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+ std::vector< int > & /*subIDArray*/ ) const
{
typedef ::GHS3DPlugin_Hypothesis THyp;
const THyp* h = static_cast< const THyp*>( myBaseImpl );
bool
GHS3DPlugin_Hypothesis_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+ std::vector< int > & /*subIDArray*/ )
{
typedef ::GHS3DPlugin_Hypothesis THyp;
THyp* h = static_cast< THyp*>( myBaseImpl );
/*!
* Maximal size of memory to be used by the algorithm (in Megabytes)
*/
- void SetMaximumMemory(CORBA::Float MB) throw ( SALOME::SALOME_Exception );
+ void SetMaximumMemory(CORBA::Float MB);
CORBA::Float GetMaximumMemory();
/*!
* Initial size of memory to be used by the algorithm (in Megabytes) in
* automatic memory adjustment mode. Default is zero
*/
- void SetInitialMemory(CORBA::Float MB) throw ( SALOME::SALOME_Exception );
+ void SetInitialMemory(CORBA::Float MB);
CORBA::Float GetInitialMemory();
/*!
* Optimization level: 0-none, 1-light, 2-medium, 3-strong. Default is medium
*/
- void SetOptimizationLevel(CORBA::Short level) throw ( SALOME::SALOME_Exception );
+ void SetOptimizationLevel(CORBA::Short level);
CORBA::Short GetOptimizationLevel();
/*!
* Path to working directory
*/
- void SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception );
+ void SetWorkingDirectory(const char* path);
char* GetWorkingDirectory();
/*!
* To keep working files or remove them. Log file remains in case of errors anyway.
* histogram of the skin mesh, quality statistics histogram together with
* the characteristics of the final mesh.
*/
- void SetVerboseLevel(CORBA::Short level) throw ( SALOME::SALOME_Exception );
+ void SetVerboseLevel(CORBA::Short level);
CORBA::Short GetVerboseLevel();
/*!
* To create new nodes
/*!
* To set hiden/undocumented/advanced options
*/
- void SetAdvancedOption(const char* option) throw (SALOME::SALOME_Exception);
+ void SetAdvancedOption(const char* option);
char* GetAdvancedOption();
void SetTextOption(const char* option); // obsolete
char* GetTextOption();
- void SetOptionValue(const char* optionName, const char* optionValue) throw (SALOME::SALOME_Exception);
- char* GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception);
+ void SetOptionValue(const char* optionName, const char* optionValue);
+ char* GetOptionValue(const char* optionName);
void UnsetOption(const char* optionName);
GHS3DPlugin::string_array* GetOptionValues();
GHS3DPlugin::string_array* GetAdvancedOptionValues();
- void SetOptionValues(const GHS3DPlugin::string_array& options) throw (SALOME::SALOME_Exception);
+ void SetOptionValues(const GHS3DPlugin::string_array& options);
void SetAdvancedOptionValues(const GHS3DPlugin::string_array& options);
void AddOption(const char* optionName, const char* optionValue);
*/
bool p_SetEnforcedVertex(CORBA::Double size, CORBA::Double x = 0, CORBA::Double y = 0, CORBA::Double z = 0,
const char* theVertexName = "", const char* theVertexEntry = "", const char* theGroupName = "",
- CORBA::Boolean isCompound = false)
- throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size) throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName) throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName) throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName) throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size) throw (SALOME::SALOME_Exception);
- bool SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName) throw (SALOME::SALOME_Exception);
- CORBA::Double GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception);
- CORBA::Double GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) throw (SALOME::SALOME_Exception);
- bool RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception);
- bool RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean isCompound = false);
+ bool SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size);
+ bool SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName);
+ bool SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName);
+ bool SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName);
+ bool SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size);
+ bool SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName);
+ CORBA::Double GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ CORBA::Double GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex);
+ bool RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ bool RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex);
GHS3DPlugin::GHS3DEnforcedVertexList* GetEnforcedVertices();
void ClearEnforcedVertices();
/*!
* To set an enforced mesh
*/
- bool p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, const char* theName="", const char* theGroupName="") throw (SALOME::SALOME_Exception);
- bool SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType) throw (SALOME::SALOME_Exception);
- bool SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, const char* theGroupName) throw (SALOME::SALOME_Exception);
+ bool p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, const char* theName="", const char* theGroupName="");
+ bool SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType);
+ bool SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, const char* theGroupName);
/* OBSOLETE FUNCTIONS */
- bool SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, double size) throw (SALOME::SALOME_Exception);
- bool SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, double size, const char* theGroupName) throw (SALOME::SALOME_Exception);
+ bool SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, double /*size*/);
+ bool SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, double /*size*/, const char* theGroupName);
/* OBSOLETE FUNCTIONS */
GHS3DPlugin::GHS3DEnforcedMeshList* GetEnforcedMeshes();
*/
//================================================================================
-bool GHS3DPlugin_Optimizer::Evaluate(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape,
- MapShapeNbElems& aResMap)
+bool GHS3DPlugin_Optimizer::Evaluate(SMESH_Mesh& /*aMesh*/, const TopoDS_Shape& /*aShape*/,
+ MapShapeNbElems& /*aResMap*/)
{
return false;
}
*/
//================================================================================
-bool GHS3DPlugin_Optimizer::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+bool GHS3DPlugin_Optimizer::Compute(SMESH_Mesh & /*aMesh*/, const TopoDS_Shape & /*aShape*/)
{
return false;
}
virtual bool Compute(SMESH_Mesh& theMesh,
SMESH_MesherHelper* theHelper);
- virtual bool Compute(SMESH_Mesh & aMesh,
+ virtual bool Compute(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape);
static const char* Name() { return "MG-Tetra Optimization"; }
return load;
}
-bool GHS3DPlugin_OptimizerHypothesis::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
+bool GHS3DPlugin_OptimizerHypothesis::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/)
{
return false;
}
-bool GHS3DPlugin_OptimizerHypothesis::SetParametersByDefaults(const TDefaults& theDflts,
- const SMESH_Mesh* theMesh)
+bool GHS3DPlugin_OptimizerHypothesis::SetParametersByDefaults(const TDefaults& /*theDflts*/,
+ const SMESH_Mesh* /*theMesh*/)
{
return false;
}
_nbRequiredTria = nb;
}
- void AddNode( double x, double y, double z, int domain )
+ void AddNode( double x, double y, double z, int /*domain*/ )
{
_xyz.push_back( x );
_xyz.push_back( y );
_nodeSize.push_back( size );
}
- void AddEdgeNodes( int node1, int node2, int domain )
+ void AddEdgeNodes( int node1, int node2, int /*domain*/ )
{
_edgeNodes.push_back( node1 );
_edgeNodes.push_back( node2 );
}
- void AddTriaNodes( int node1, int node2, int node3, int domain )
+ void AddTriaNodes( int node1, int node2, int node3, int /*domain*/ )
{
_triaNodes.push_back( node1 );
_triaNodes.push_back( node2 );
_triaNodes.push_back( node3 );
}
- void AddTetraNodes( int node1, int node2, int node3, int node4, int domain )
+ void AddTetraNodes( int node1, int node2, int node3, int node4, int /*domain*/ )
{
_tetraNodes.push_back( node1 );
_tetraNodes.push_back( node2 );
return true;
}
+#else // ifdef USE_MG_LIBS
+
+struct MG_Tetra_API::LibData // to avoid compiler warnings
+{
+ volatile bool& _cancelled_flag;
+ double& _progress;
+ LibData(volatile bool& cancelled_flag, double& progress): _cancelled_flag{cancelled_flag}, _progress{progress} {}
+};
#endif // ifdef USE_MG_LIBS
MG_Tetra_API::MG_Tetra_API(volatile bool& cancelled_flag, double& progress)
{
_useLib = false;
+ _libData = new LibData( cancelled_flag, progress );
#ifdef USE_MG_LIBS
_useLib = true;
- _libData = new LibData( cancelled_flag, progress );
_libData->Init();
if ( getenv("MG_TETRA_USE_EXE"))
_useLib = false;
*/
//================================================================================
-void MG_Tetra_API::GmfGetLin( int iMesh, GmfKwdCod what, int* nbNodes, int* faceInd, int* ori, int* domain, int dummy )
+void MG_Tetra_API::GmfGetLin( int iMesh, GmfKwdCod what, int* nbNodes, int* faceInd, int* ori, int* domain, int /*dummy*/ )
{
if ( _useLib ) {
#ifdef USE_MG_LIBS
{
myEnforcedTableWidget->disconnect(SIGNAL( itemChanged(QTableWidgetItem *)));
bool okToCreate = true;
- double itemX,itemY,itemZ,itemSize = 0;
+ double itemX=0.,itemY=0.,itemZ=0.,itemSize = 0; // todo: itemX, itemY, itemZ must be explicitly initialized to avoid warning (see below)
QString itemEntry, itemGroupName = QString("");
// bool itemIsCompound;
int rowCount = myEnforcedTableWidget->rowCount();
break;
- if (( !isCompound && ((itemX == x) && (itemY == y) && (itemZ == z))) ||
+ if (( !isCompound && ((itemX == x) && (itemY == y) && (itemZ == z))) || // todo: itemX, itemY, itemZ must be explicitly initialized to avoid warning (see above)
( !itemEntry.isEmpty() && ( itemEntry == geomEntry.c_str() )))
{
// update size
myEnforcedTableWidget->selectionModel()->clearSelection();
}
-void GHS3DPluginGUI_HypothesisCreator::onToMeshHoles(bool isOn)
+void GHS3DPluginGUI_HypothesisCreator::onToMeshHoles(bool /*isOn*/)
{
// myToMakeGroupsOfDomains->setEnabled( isOn );
// if ( !isOn )
_PTR(SObject) aSObj = aStudy->FindObjectID(enfMesh->entry.c_str());
SMESH::SMESH_IDSource_var theSource = SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aSObj );
- SMESH::ElementType elementType;
+ SMESH::ElementType elementType = SMESH::NODE; // todo: elementType must be explicitly initialized to avoid warning (see below)
switch(enfMesh->elementType) {
case 0:
elementType = SMESH::NODE;
break;
}
- ok = h->p_SetEnforcedMesh(theSource, elementType, enfMesh->name.c_str(), enfMesh->groupName.c_str());
+ ok = h->p_SetEnforcedMesh(theSource, elementType, enfMesh->name.c_str(), enfMesh->groupName.c_str()); // todo: elementType must be explicitly initialized to avoid warning (see above)
} // for
} // try
catch ( const SALOME::SALOME_Exception& ex )