#18963 Minimize compiler warnings

diff --git a/src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx b/src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx
index 0e99ccf37f550e09826dd4b9514aec45913ad2b2..714f7329a9c401fcb096cf6b14447c7c5b84c14f 100644 (file)
--- a/src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx
+++ b/src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx
@@ -988,7 +988,7 @@ void HYBRIDPluginGUI_HypothesisCreator::addEnforcedVertex(double x, double y, do
 {
   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();
@@ -1036,7 +1036,7 @@ void HYBRIDPluginGUI_HypothesisCreator::addEnforcedVertex(double x, double y, do
       break;
 
 
-    if (( !isCompound && ((itemX == x) && (itemY == y) && (itemZ == z))) || /*( (itemEntry.toStdString() != "") && */ (itemEntry.toStdString() == geomEntry)/*)*/) {
+    if (( !isCompound && ((itemX == x) && (itemY == y) && (itemZ == z))) || /*( (itemEntry.toStdString() != "") && */ (itemEntry.toStdString() == geomEntry)/*)*/) { // todo: itemX, itemY, itemZ must be explicitly initialized to avoid warning (see above)
       // update size
       if (itemSize != size) {
         myEnforcedTableWidget->item(row, ENF_VER_SIZE_COLUMN)->setData( Qt::EditRole, QVariant(size));
@@ -1782,7 +1782,7 @@ bool HYBRIDPluginGUI_HypothesisCreator::storeParamsToHypo( const HYBRIDHypothesi
       _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;
@@ -1797,7 +1797,7 @@ bool HYBRIDPluginGUI_HypothesisCreator::storeParamsToHypo( const HYBRIDHypothesi
           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 std::exception& ex) {

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx
index 07dec79d5b1be3ed7d1616565e319f5a229b9001..af748c7cc1055403b1be120a1deea31e1f6f5633 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx
@@ -190,7 +190,7 @@ TopoDS_Shape HYBRIDPlugin_HYBRID::entryToShape(std::string entry)
 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
 
@@ -329,13 +329,13 @@ static bool readGMFFile(MG_HYBRID_API*                          MGOutput,
                         SMESH_MesherHelper*                     theHelper,
                         std::vector <const SMDS_MeshNode*> &    theNodeByHybridId,
                         std::vector <const SMDS_MeshElement*> & theFaceByHybridId,
-                        std::map<const SMDS_MeshNode*,int> &    theNodeToHybridIdMap,
+                        std::map<const SMDS_MeshNode*,int> &    /*theNodeToHybridIdMap*/,
                         std::vector<std::string> &              aNodeGroupByHybridId,
                         std::vector<std::string> &              anEdgeGroupByHybridId,
                         std::vector<std::string> &              aFaceGroupByHybridId,
                         std::set<std::string> &                 groupsToRemove,
                         bool                                    toMakeGroupsOfDomains=false,
-                        bool                                    toMeshHoles=true)
+                        bool                                    /*toMeshHoles*/=true)
 {
   std::string tmpStr;
   SMESHDS_Mesh* theMeshDS = theHelper->GetMeshDS();
@@ -378,15 +378,15 @@ static bool readGMFFile(MG_HYBRID_API*                          MGOutput,
     theFaceByHybridId.clear();
   }
 
-  int nbMeshNodes = theMeshDS->NbNodes();
   int nbInitialNodes = theNodeByHybridId.size();
 
+#ifdef _DEBUG_
+  int nbMeshNodes = theMeshDS->NbNodes();
   const bool isQuadMesh =
     theHelper->GetMesh()->NbEdges( ORDER_QUADRATIC ) ||
     theHelper->GetMesh()->NbFaces( ORDER_QUADRATIC ) ||
     theHelper->GetMesh()->NbVolumes( ORDER_QUADRATIC );
 
-#ifdef _DEBUG_
   std::cout << "theNodeByHybridId.size(): " << nbInitialNodes << std::endl;
   std::cout << "theHelper->GetMesh()->NbNodes(): " << nbMeshNodes << std::endl;
   std::cout << "isQuadMesh: " << isQuadMesh << std::endl;
@@ -2298,9 +2298,9 @@ namespace
      */
     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 &&
@@ -2339,11 +2339,11 @@ namespace
     /*!
      * \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() )

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx
index fea8bd7c8c761f0c31f53a348ccd821dd6343ed3..7980520148569bc0de4bf5fa7d4c220805e26ff3 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx
@@ -180,7 +180,7 @@ void HYBRIDPlugin_Hypothesis::SetLayersOnAllWrap(bool toMesh)
 //function : GetLayersOnAllWrap
 //=======================================================================
 
-bool HYBRIDPlugin_Hypothesis::GetLayersOnAllWrap(bool checkFreeOption) const
+bool HYBRIDPlugin_Hypothesis::GetLayersOnAllWrap(bool /*checkFreeOption*/) const
 {
   return myLayersOnAllWrap;
 }
@@ -279,7 +279,7 @@ void HYBRIDPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
 //function : GetToMeshHoles
 //=======================================================================
 
-bool HYBRIDPlugin_Hypothesis::GetToMeshHoles(bool checkFreeOption) const
+bool HYBRIDPlugin_Hypothesis::GetToMeshHoles(bool /*checkFreeOption*/) const
 {
   return myToMeshHoles;
 }
@@ -1046,7 +1046,6 @@ bool HYBRIDPlugin_Hypothesis::SetEnforcedElements(TIDSortedElemSet theElemSet, S
 //=======================================================================
 
 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(double x, double y, double z)
-  throw (std::invalid_argument)
 {
   std::vector<double> coord(3);
   coord[0] = x;
@@ -1060,7 +1059,6 @@ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnfo
 }
 
 HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(const std::string theEntry)
-  throw (std::invalid_argument)
 {
   if (_geomEntryEnfVertexMap.count(theEntry)>0)
     return _geomEntryEnfVertexMap[theEntry];
@@ -1075,7 +1073,6 @@ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnfo
 //=======================================================================
 
 bool HYBRIDPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z, const std::string theEntry)
-  throw (std::invalid_argument)
 {
   bool toNotify = false;
   std::ostringstream msg;
@@ -2186,7 +2183,6 @@ std::string HYBRIDPlugin_Hypothesis::GetExeName()
 //=============================================================================
 void HYBRIDPlugin_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())
@@ -2251,7 +2247,6 @@ void HYBRIDPlugin_Hypothesis::SetOptionValue(const std::string& optionName,
 //  empty if it equals a default one.
 std::string HYBRIDPlugin_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())
@@ -2284,7 +2279,7 @@ bool HYBRIDPlugin_Hypothesis::HasOptionDefined( const std::string& optionName )
   {
     GetOptionValue( optionName, &isDefault );
   }
-  catch ( std::invalid_argument )
+  catch ( std::invalid_argument& )
   {
     return false;
   }
@@ -2322,7 +2317,6 @@ HYBRIDPlugin_Hypothesis::TOptionValues HYBRIDPlugin_Hypothesis::GetOptionValues(
 //================================================================================
 
 bool HYBRIDPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
-  throw (std::invalid_argument)
 {
   std::string s = str;
   if ( isOk ) *isOk = true;
@@ -2352,7 +2346,6 @@ bool HYBRIDPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
 //================================================================================
 
 double HYBRIDPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
-  throw (std::invalid_argument)
 {
   if ( str.empty() ) throw std::invalid_argument("Empty value provided");
 
@@ -2377,7 +2370,6 @@ double HYBRIDPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
 //================================================================================
 
 int HYBRIDPlugin_Hypothesis::ToInt(const std::string& str, bool* isOk )
-  throw (std::invalid_argument)
 {
   if ( str.empty() ) throw std::invalid_argument("Empty value provided");
 

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx
index 3efad3fdb67625bc19fdd8b7b14dc83518d51fc8..b246b6ed1b9f8179e01ac24c418c7929bf9ca098 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx
@@ -309,17 +309,17 @@ public:
   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;
   const TOptionValues& GetCustomOptionValues() const { return _customOption2value; }
 
-  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);
 
 
   /*!
@@ -344,9 +344,9 @@ public:
    */
   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);
-  THYBRIDEnforcedVertex* GetEnforcedVertex(double x, double y, double z) throw (std::invalid_argument);
-  THYBRIDEnforcedVertex* 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);
+  THYBRIDEnforcedVertex* GetEnforcedVertex(double x, double y, double z);
+  THYBRIDEnforcedVertex* GetEnforcedVertex(const std::string anEntry);
+  bool RemoveEnforcedVertex(double x=0.0, double y=0.0, double z=0.0, const std::string anEntry="" );
   const THYBRIDEnforcedVertexCoordsValues _GetEnforcedVerticesCoordsSize() const {return _enfVertexCoordsSizeList; }
   const THYBRIDEnforcedVertexEntryValues  _GetEnforcedVerticesEntrySize() const {return _enfVertexEntrySizeList; }
   const THYBRIDEnforcedVertexList         _GetEnforcedVertices() const { return _enfVertexList; }

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx
index cefad10734e0ff3dc0e8d9f2215340b4e4f09d6a..610065729953e7b41de12456f3688d1b4418992f 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx
@@ -260,7 +260,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
 //=======================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Double MB)
-   throw ( SALOME::SALOME_Exception )
 {
   if ( MB == 0 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
@@ -284,7 +283,6 @@ CORBA::Double HYBRIDPlugin_Hypothesis_i::GetMaximumMemory()
 //=======================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetInitialMemory(CORBA::Double MB)
-  throw ( SALOME::SALOME_Exception )
 {
   if ( MB == 0 )
     THROW_SALOME_CORBA_EXCEPTION( "Invalid memory size",SALOME::BAD_PARAM );
@@ -308,7 +306,6 @@ CORBA::Double HYBRIDPlugin_Hypothesis_i::GetInitialMemory()
 //=======================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
-  throw ( SALOME::SALOME_Exception )
 {
   ::HYBRIDPlugin_Hypothesis::OptimizationLevel l =
       (::HYBRIDPlugin_Hypothesis::OptimizationLevel) level;
@@ -336,7 +333,6 @@ CORBA::Short HYBRIDPlugin_Hypothesis_i::GetOptimizationLevel()
 //function : SetCollisionMode
 //=======================================================================
 void HYBRIDPlugin_Hypothesis_i::SetCollisionMode(CORBA::Short level)
-  throw ( SALOME::SALOME_Exception )
 {
   ::HYBRIDPlugin_Hypothesis::CollisionMode l =
       (::HYBRIDPlugin_Hypothesis::CollisionMode) level;
@@ -361,7 +357,7 @@ CORBA::Short HYBRIDPlugin_Hypothesis_i::GetCollisionMode()
 //=======================================================================
 //function : SetWorkingDirectory
 //=======================================================================
-void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
+void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path)
 {
   if (!path )
     THROW_SALOME_CORBA_EXCEPTION( "Null working directory",SALOME::BAD_PARAM );
@@ -413,7 +409,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles()
 //function : SetVerboseLevel
 //=======================================================================
 void HYBRIDPlugin_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]",
@@ -519,7 +514,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToRemoveCentralPoint()
 //=============================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   try {
@@ -597,7 +591,7 @@ void HYBRIDPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const cha
       try {
         valueChanged = ( this->GetImpl()->GetOptionValue( name ) != optionValue );
       }
-      catch ( std::invalid_argument ) {
+      catch ( std::invalid_argument& ) {
       }
       if ( valueChanged )
       {
@@ -615,7 +609,6 @@ void HYBRIDPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const cha
 //=============================================================================
 
 char* HYBRIDPlugin_Hypothesis_i::GetOptionValue(const char* optionName)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   try {
@@ -693,7 +686,6 @@ HYBRIDPlugin::string_array* HYBRIDPlugin_Hypothesis_i::GetAdvancedOptionValues()
 //=============================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetOptionValues(const HYBRIDPlugin::string_array& options)
-  throw (SALOME::SALOME_Exception)
 {
   for (CORBA::ULong i = 0; i < options.length(); ++i)
   {
@@ -754,7 +746,6 @@ void HYBRIDPlugin_Hypothesis_i::SetAdvancedOptionValues(const HYBRIDPlugin::stri
 //=============================================================================
 
 void HYBRIDPlugin_Hypothesis_i::SetAdvancedOption(const char* optionsAndValues)
-  throw (SALOME::SALOME_Exception)
 {
   if ( !optionsAndValues ) return;
 
@@ -907,7 +898,6 @@ CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
 //function : SetBoundaryLayersGrowth
 //=======================================================================
 void HYBRIDPlugin_Hypothesis_i::SetBoundaryLayersGrowth(CORBA::Short level)
-  throw ( SALOME::SALOME_Exception )
 {
   ::HYBRIDPlugin_Hypothesis::BoundaryLayersGrowth l =
       (::HYBRIDPlugin_Hypothesis::BoundaryLayersGrowth) level;
@@ -933,7 +923,6 @@ CORBA::Short HYBRIDPlugin_Hypothesis_i::GetBoundaryLayersGrowth()
 //function : SetElementGeneration
 //=======================================================================
 void HYBRIDPlugin_Hypothesis_i::SetElementGeneration(CORBA::Short level)
-  throw ( SALOME::SALOME_Exception )
 {
   ::HYBRIDPlugin_Hypothesis::ElementGeneration l =
       (::HYBRIDPlugin_Hypothesis::ElementGeneration) level;
@@ -1093,31 +1082,31 @@ CORBA::Short HYBRIDPlugin_Hypothesis_i::GetNbOfBoundaryLayers()
 //=======================================================================
 
 bool HYBRIDPlugin_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 HYBRIDPlugin_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 HYBRIDPlugin_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 HYBRIDPlugin_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 HYBRIDPlugin_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)) {
@@ -1159,7 +1148,7 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theV
 }
 
 bool HYBRIDPlugin_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)) {
@@ -1204,7 +1193,7 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
 bool HYBRIDPlugin_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;
 
@@ -1280,7 +1269,6 @@ bool HYBRIDPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::
 //=======================================================================
 
 CORBA::Double HYBRIDPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   try {
@@ -1306,7 +1294,6 @@ CORBA::Double HYBRIDPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORB
 //=======================================================================
 
 CORBA::Double HYBRIDPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   
@@ -1398,7 +1385,6 @@ HYBRIDPlugin::HYBRIDEnforcedVertexList* HYBRIDPlugin_Hypothesis_i::GetEnforcedVe
 //=======================================================================
 
 bool HYBRIDPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   try {
@@ -1420,7 +1406,6 @@ bool HYBRIDPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Dou
 }
 
 bool HYBRIDPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   
@@ -1523,7 +1508,6 @@ HYBRIDPlugin::HYBRIDEnforcedMeshList* HYBRIDPlugin_Hypothesis_i::GetEnforcedMesh
  * \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource. The elements will be grouped in theGroupName.
  */
 bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
 {
 // #if HYBRID_VERSION >= 42
   return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
@@ -1541,7 +1525,6 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_p
  * \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource.
  */
 bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType)
-  throw (SALOME::SALOME_Exception)
 {
 // #if HYBRID_VERSION >= 42
   return p_SetEnforcedMesh(theSource, theType);
@@ -1558,8 +1541,7 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSou
 /*!
  * \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 HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double /*theSize*/, const char* theGroupName)
 {
 // #if HYBRID_VERSION >= 42
   return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
@@ -1576,8 +1558,7 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSour
 /*!
  * \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size.
  */
-bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize)
-  throw (SALOME::SALOME_Exception)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double /*theSize*/)
 {
 // #if HYBRID_VERSION >= 42
   return p_SetEnforcedMesh(theSource, theType);
@@ -1592,7 +1573,6 @@ bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr th
 }
 
 bool HYBRIDPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theName, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
 {
   ASSERT(myBaseImpl);
   

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx
index 76c064cda324de248583bdbc4590cffae4c745fc..93af230d6aaca2133f770a152709961e1857f468 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx
@@ -94,28 +94,28 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
   /*!
    * Maximal size of memory to be used by the algorithm (in Megabytes)
    */
-  void SetMaximumMemory(CORBA::Double MB) throw ( SALOME::SALOME_Exception );
+  void SetMaximumMemory(CORBA::Double MB);
   CORBA::Double GetMaximumMemory();
   /*!
    * Initial size of memory to be used by the algorithm (in Megabytes) in
    * automatic memory adjustment mode. Default is zero
    */
-  void SetInitialMemory(CORBA::Double MB) throw ( SALOME::SALOME_Exception );
+  void SetInitialMemory(CORBA::Double MB);
   CORBA::Double 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();
   /*!
    * Collision Mode: 0-decrease, 1-stop. Default is decrease
    */
-  void SetCollisionMode(CORBA::Short mode) throw ( SALOME::SALOME_Exception );
+  void SetCollisionMode(CORBA::Short mode);
   CORBA::Short GetCollisionMode();
   /*!
    * 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.
@@ -132,7 +132,7 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
    *     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
@@ -159,14 +159,14 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
   void SetToRemoveCentralPoint(CORBA::Boolean toRemove);
   CORBA::Boolean GetToRemoveCentralPoint();
 
-  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);
 
   HYBRIDPlugin::string_array* GetOptionValues();
   HYBRIDPlugin::string_array* GetAdvancedOptionValues();
 
-  void SetOptionValues(const HYBRIDPlugin::string_array& options) throw (SALOME::SALOME_Exception);
+  void SetOptionValues(const HYBRIDPlugin::string_array& options);
   void SetAdvancedOptionValues(const HYBRIDPlugin::string_array& options);
 
   void AddOption(const char* optionName, const char* optionValue);
@@ -174,7 +174,7 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
   /*!
    * To set hiden/undocumented/advanced options
    */
-  void SetAdvancedOption(const char* theOptAndVals ) throw (SALOME::SALOME_Exception);
+  void SetAdvancedOption(const char* theOptAndVals );
   char* GetAdvancedOption();
   void SetTextOption(const char* option);
   char* GetTextOption();
@@ -194,10 +194,10 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
   void SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess);
   CORBA::Boolean GetRemoveLogOnSuccess();
   
-  void SetBoundaryLayersGrowth(CORBA::Short mode) throw ( SALOME::SALOME_Exception );
+  void SetBoundaryLayersGrowth(CORBA::Short mode);
   CORBA::Short GetBoundaryLayersGrowth();
 
-  void SetElementGeneration(CORBA::Short mode) throw ( SALOME::SALOME_Exception );
+  void SetElementGeneration(CORBA::Short mode);
   CORBA::Short GetElementGeneration();
 
   void SetAddMultinormals(CORBA::Boolean toAddMultinormals);
@@ -226,30 +226,29 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
    */
   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);
   HYBRIDPlugin::HYBRIDEnforcedVertexList* 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 */
 
   HYBRIDPlugin::HYBRIDEnforcedMeshList* GetEnforcedMeshes();
@@ -262,10 +261,10 @@ class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
   CORBA::Boolean IsDimSupported( SMESH::Dimension type );
   
   // Methods for copying mesh definition to other geometry
-  virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & subIDArray ) const { return false; }
-  virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
-                                   std::vector< int >         & subIDArray ) { return true; }
+  virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+                                   std::vector< int >         & /*subIDArray*/ ) const { return false; }
+  virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+                                   std::vector< int >         & /*subIDArray*/ ) { return true; }
 };
 
 #endif

diff --git a/src/HYBRIDPlugin/HYBRIDPlugin_i.cxx b/src/HYBRIDPlugin/HYBRIDPlugin_i.cxx
index b54cf6e86b6b471b02337ecb3545cc97130c0175..628162b428deb2760cc2c529e771595fb785521b 100644 (file)
--- a/src/HYBRIDPlugin/HYBRIDPlugin_i.cxx
+++ b/src/HYBRIDPlugin/HYBRIDPlugin_i.cxx
@@ -58,7 +58,6 @@ extern "C"
     // Hypothesis
     else if (strcmp(aHypName, "HYBRID_Parameters") == 0)
       aCreator = new HYBRIDPlugin_Creator_i<HYBRIDPlugin_Hypothesis_i>;
-    else ;
 
     return aCreator;
   }

diff --git a/src/HYBRIDPlugin/MG_HYBRID_API.cxx b/src/HYBRIDPlugin/MG_HYBRID_API.cxx
index 6ad3f0d65c75a37eb2c3c49dc5abb0e0ea3ab911..fb5856a15eab691fe7e15e76022db6f18a31ddb7 100644 (file)
--- a/src/HYBRIDPlugin/MG_HYBRID_API.cxx
+++ b/src/HYBRIDPlugin/MG_HYBRID_API.cxx
@@ -340,7 +340,7 @@ struct MG_HYBRID_API::LibData
   }
 
   void ReadPrismNodes( int* node1, int* node2, int* node3, int* node4,
-                       int* node5, int* node6, int* domain )
+                       int* node5, int* node6, int* /*domain*/ )
   {
     integer vtx[6];
     status_t ret = mesh_get_prism_vertices( _hybrid_mesh, _count, vtx);
@@ -428,7 +428,7 @@ struct MG_HYBRID_API::LibData
     _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 );
@@ -730,6 +730,14 @@ bool MG_HYBRID_API::LibData::Compute()
   return true;
 }
 
+#else // ifdef USE_MG_LIBS
+
+struct MG_HYBRID_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
 
@@ -743,9 +751,9 @@ bool MG_HYBRID_API::LibData::Compute()
 MG_HYBRID_API::MG_HYBRID_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_HYBRID_USE_EXE"))
     _useLib = false;
@@ -931,7 +939,7 @@ void MG_HYBRID_API::GmfGotoKwd( int iMesh, GmfKwdCod what )
  */
 //================================================================================
 
-void MG_HYBRID_API::GmfGetLin( int iMesh, GmfKwdCod what, int* nbNodes, int* faceInd, int* ori, int* domain, int dummy )
+void MG_HYBRID_API::GmfGetLin( int iMesh, GmfKwdCod what, int* nbNodes, int* faceInd, int* ori, int* domain, int /*dummy*/ )
 {
   if ( _useLib ) {
 #ifdef USE_MG_LIBS