fight warnings c++17 error throw(). Build BLSURFPLUGIN finished

diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
index 7c6ea55bd348e54e5dcb27a8042a9f67e6bec65c..5871959d67fd80af3986d445cc342ad3af528e4f 100644 (file)
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx
@@ -637,7 +637,7 @@ bool BLSURFPlugin_Hypothesis::GetUseDeprecatedPatchMesher()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetMaxNumberOfPointsPerPatch( int nb )
-  throw (std::invalid_argument)
+  
 {
 #if MESHGEMS_VERSION_HEX < 0x020A00
   // Deprecated since MeshGems 2.10
@@ -664,7 +664,7 @@ int BLSURFPlugin_Hypothesis::GetMaxNumberOfPointsPerPatch()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetMaxNumberOfThreads( int nb )
-  throw (std::invalid_argument)
+  
 {
   if ( nb < 0 )
     throw std::invalid_argument( SMESH_Comment("Invalid number of threads: ") << nb );
@@ -743,7 +743,7 @@ bool BLSURFPlugin_Hypothesis::GetDebug()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetPeriodicTolerance( CORBA::Double tol )
-  throw (std::invalid_argument)
+  
 {
   if ( tol <= 0 )
     throw std::invalid_argument( SMESH_Comment("Invalid tolerance: ") << tol );
@@ -761,7 +761,7 @@ double BLSURFPlugin_Hypothesis::GetPeriodicTolerance()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetRequiredEntities( const std::string& howToTreat )
-  throw (std::invalid_argument)
+  
 {
   if ( howToTreat != "respect" && howToTreat != "ignore" && howToTreat != "clear"  )
     throw std::invalid_argument
@@ -781,7 +781,7 @@ std::string BLSURFPlugin_Hypothesis::GetRequiredEntities()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetSewingTolerance( CORBA::Double tol )
-  throw (std::invalid_argument)
+  
 {
   if ( tol <= 0 )
     throw std::invalid_argument( SMESH_Comment("Invalid tolerance: ") << tol );
@@ -799,7 +799,7 @@ CORBA::Double BLSURFPlugin_Hypothesis::GetSewingTolerance()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis::SetTags( const std::string& howToTreat )
-  throw (std::invalid_argument)
+  
 {
   if ( howToTreat != "respect" && howToTreat != "ignore" && howToTreat != "clear"  )
     throw std::invalid_argument
@@ -964,7 +964,7 @@ void BLSURFPlugin_Hypothesis::SetGMFFile(const std::string& theFileName)
 
 //=============================================================================
 void BLSURFPlugin_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())
@@ -1021,7 +1021,7 @@ void BLSURFPlugin_Hypothesis::SetOptionValue(const std::string& optionName, cons
 
 //=============================================================================
 void BLSURFPlugin_Hypothesis::SetPreCADOptionValue(const std::string& optionName, const std::string& optionValue)
-  throw (std::invalid_argument) {
+   {
 
   TOptionValues::iterator op_val = _preCADoption2value.find(optionName);
   if (op_val == _preCADoption2value.end()) {
@@ -1081,7 +1081,7 @@ void BLSURFPlugin_Hypothesis::SetPreCADOptionValue(const std::string& optionName
 //=============================================================================
 std::string BLSURFPlugin_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())
@@ -1112,7 +1112,7 @@ std::string BLSURFPlugin_Hypothesis::GetOptionValue(const std::string& optionNam
 //=============================================================================
 std::string BLSURFPlugin_Hypothesis::GetPreCADOptionValue(const std::string& optionName,
                                                           bool*              isDefault) const
-  throw (std::invalid_argument)
+  
 {
   TOptionValues::const_iterator op_val = _preCADoption2value.find(optionName);
   if (op_val == _preCADoption2value.end())
@@ -1573,7 +1573,7 @@ void BLSURFPlugin_Hypothesis::AddEnforcedVertex( const TEntry& faceEntry,
 //=======================================================================
 
 BLSURFPlugin_Hypothesis::TEnfVertexList BLSURFPlugin_Hypothesis::GetEnfVertexList(const TEntry& theFaceEntry)
-    throw (std::invalid_argument) {
+     {
 
   if (_faceEntryEnfVertexListMap.count(theFaceEntry) > 0)
     return _faceEntryEnfVertexListMap[theFaceEntry];
@@ -1590,7 +1590,7 @@ BLSURFPlugin_Hypothesis::TEnfVertexList BLSURFPlugin_Hypothesis::GetEnfVertexLis
 //=======================================================================
 
 BLSURFPlugin_Hypothesis::TEnfVertexCoordsList BLSURFPlugin_Hypothesis::GetEnfVertexCoordsList(
-    const TEntry& theFaceEntry) throw (std::invalid_argument) {
+    const TEntry& theFaceEntry)  {
 
   if (_faceEntryCoordsListMap.count(theFaceEntry) > 0)
     return _faceEntryCoordsListMap[theFaceEntry];
@@ -1605,7 +1605,7 @@ BLSURFPlugin_Hypothesis::TEnfVertexCoordsList BLSURFPlugin_Hypothesis::GetEnfVer
 //=======================================================================
 
 BLSURFPlugin_Hypothesis::TEntryList BLSURFPlugin_Hypothesis::GetEnfVertexEntryList(const TEntry& theFaceEntry)
-    throw (std::invalid_argument) {
+     {
 
   if (_faceEntryEnfVertexEntryListMap.count(theFaceEntry) > 0)
     return _faceEntryEnfVertexEntryListMap[theFaceEntry];
@@ -1620,7 +1620,7 @@ BLSURFPlugin_Hypothesis::TEntryList BLSURFPlugin_Hypothesis::GetEnfVertexEntryLi
 //=======================================================================
 
 BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(TEnfVertexCoords coords)
-    throw (std::invalid_argument) {
+     {
 
   if (_coordsEnfVertexMap.count(coords) > 0)
     return _coordsEnfVertexMap[coords];
@@ -1635,7 +1635,7 @@ BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(TEnfV
 //=======================================================================
 
 BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(const TEntry& theEnfVertexEntry)
-    throw (std::invalid_argument) {
+     {
 
   if (_enfVertexEntryEnfVertexMap.count(theEnfVertexEntry) > 0)
     return _enfVertexEntryEnfVertexMap[theEnfVertexEntry];
@@ -1662,7 +1662,7 @@ BLSURFPlugin_Hypothesis::TEnfVertex* BLSURFPlugin_Hypothesis::GetEnfVertex(const
 //=======================================================================
 
 bool BLSURFPlugin_Hypothesis::ClearEnforcedVertex(const TEntry& theFaceEntry, double x, double y, double z,
-    const TEntry& theVertexEntry) throw (std::invalid_argument) {
+    const TEntry& theVertexEntry)  {
 
   bool toNotify = false;
   std::ostringstream msg;
@@ -1748,7 +1748,7 @@ bool BLSURFPlugin_Hypothesis::ClearEnforcedVertex(const TEntry& theFaceEntry, do
 //function : ClearEnforcedVertices
 //=======================================================================
 
-bool BLSURFPlugin_Hypothesis::ClearEnforcedVertices(const TEntry& theFaceEntry) throw (std::invalid_argument) {
+bool BLSURFPlugin_Hypothesis::ClearEnforcedVertices(const TEntry& theFaceEntry)  {
 
   bool toNotify = false;
   TEnfVertex *oldEnfVertex;
@@ -1883,7 +1883,7 @@ BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap BLSURFPlugin_Hypothesis::Ge
   return hyp ? hyp->_GetAllEnforcedVerticesByEnfVertexEntry() : GetDefaultEnfVertexEntryEnfVertexMap();
 }
 
-std::set<int> BLSURFPlugin_Hypothesis::GetEnfVertexNodeIDs(TEnfGroupName theGroupName) throw (std::invalid_argument)
+std::set<int> BLSURFPlugin_Hypothesis::GetEnfVertexNodeIDs(TEnfGroupName theGroupName) 
 {
   TGroupNameNodeIDMap::const_iterator it = _groupNameNodeIDMap.find(theGroupName);
   if (it != _groupNameNodeIDMap.end()) {
@@ -1899,7 +1899,7 @@ void BLSURFPlugin_Hypothesis::AddEnfVertexNodeID(TEnfGroupName theGroupName,int
   _groupNameNodeIDMap[theGroupName].insert(theNodeID);
 }
 
-void BLSURFPlugin_Hypothesis::RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) throw (std::invalid_argument)
+void BLSURFPlugin_Hypothesis::RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) 
 {
   TGroupNameNodeIDMap::iterator it = _groupNameNodeIDMap.find(theGroupName);
   if (it != _groupNameNodeIDMap.end()) {
@@ -3641,7 +3641,7 @@ bool BLSURFPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  dflts,
 //================================================================================
 
 bool BLSURFPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
-  throw (std::invalid_argument)
+  
 {
   std::string s = str;
   if ( isOk ) *isOk = true;
@@ -3671,7 +3671,7 @@ bool BLSURFPlugin_Hypothesis::ToBool(const std::string& str, bool* isOk )
 //================================================================================
 
 double BLSURFPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
-  throw (std::invalid_argument)
+  
 {
   if ( str.empty() ) throw std::invalid_argument("Empty value provided");
 
@@ -3696,7 +3696,7 @@ double BLSURFPlugin_Hypothesis::ToDbl(const std::string& str, bool* isOk )
 //================================================================================
 
 int BLSURFPlugin_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/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
index f924cbbd9582e124570040b377c1bca585d1f6b2..f8ff69fc23a167f122a14b8b658bf5f3f3b59bc6 100644 (file)
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx
@@ -189,10 +189,10 @@ public:
   void SetJacobianRectification( bool allowRectification );
   bool GetJacobianRectification();
 
-  void SetMaxNumberOfPointsPerPatch( int nb ) throw (std::invalid_argument);
+  void SetMaxNumberOfPointsPerPatch( int nb );
   int  GetMaxNumberOfPointsPerPatch();
 
-  void SetMaxNumberOfThreads( int nb ) throw (std::invalid_argument);
+  void SetMaxNumberOfThreads( int nb );
   int  GetMaxNumberOfThreads();
 
   void SetRespectGeometry( bool toRespect );
@@ -207,16 +207,16 @@ public:
   void SetDebug( bool isDebug );
   bool GetDebug();
 
-  void SetPeriodicTolerance( double tol ) throw (std::invalid_argument);
+  void SetPeriodicTolerance( double tol );
   double GetPeriodicTolerance();
 
-  void SetRequiredEntities( const std::string& howToTreat ) throw (std::invalid_argument);
+  void SetRequiredEntities( const std::string& howToTreat );
   std::string GetRequiredEntities();
 
-  void SetSewingTolerance( double tol ) throw (std::invalid_argument);
+  void SetSewingTolerance( double tol );
   double GetSewingTolerance();
 
-  void SetTags( const std::string& howToTreat ) throw (std::invalid_argument);
+  void SetTags( const std::string& howToTreat );
   std::string GetTags();
 
   // Hyper-patches
@@ -380,17 +380,17 @@ public:
 
   bool                  SetEnforcedVertex(TEntry theFaceEntry, TEnfName theVertexName, TEntry theVertexEntry, TEnfGroupName theGroupName,
                                           double x = 0.0, double y = 0.0, double z = 0.0);
-  TEnfVertexList        GetEnfVertexList(const TEntry& theFaceEntry) throw (std::invalid_argument);
-  TEnfVertexCoordsList  GetEnfVertexCoordsList(const TEntry& theFaceEntry) throw (std::invalid_argument);
-  TEntryList            GetEnfVertexEntryList (const TEntry& theFaceEntry) throw (std::invalid_argument);
-  TEnfVertex*           GetEnfVertex(TEnfVertexCoords coords) throw (std::invalid_argument);
-  TEnfVertex*           GetEnfVertex(const TEntry& theEnfVertexEntry) throw (std::invalid_argument);
+  TEnfVertexList        GetEnfVertexList(const TEntry& theFaceEntry) ;
+  TEnfVertexCoordsList  GetEnfVertexCoordsList(const TEntry& theFaceEntry) ;
+  TEntryList            GetEnfVertexEntryList (const TEntry& theFaceEntry) ;
+  TEnfVertex*           GetEnfVertex(TEnfVertexCoords coords) ;
+  TEnfVertex*           GetEnfVertex(const TEntry& theEnfVertexEntry) ;
   void                  AddEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID);
-  std::set<int>         GetEnfVertexNodeIDs(TEnfGroupName theGroupName) throw (std::invalid_argument);
-  void                  RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) throw (std::invalid_argument);
+  std::set<int>         GetEnfVertexNodeIDs(TEnfGroupName theGroupName) ;
+  void                  RemoveEnfVertexNodeID(TEnfGroupName theGroupName,int theNodeID) ;
   
-  bool ClearEnforcedVertex(const TEntry& theFaceEntry, double x = 0.0, double y = 0.0, double z = 0.0, const TEntry& theVertexEntry="") throw (std::invalid_argument);
-  bool ClearEnforcedVertices(const TEntry& theFaceEntry) throw (std::invalid_argument);
+  bool ClearEnforcedVertex(const TEntry& theFaceEntry, double x = 0.0, double y = 0.0, double z = 0.0, const TEntry& theVertexEntry="") ;
+  bool ClearEnforcedVertices(const TEntry& theFaceEntry) ;
 
   void ClearAllEnforcedVertices();
   void AddEnforcedVertex( const TEntry& theFaceEntry, TEnfVertex * theEnfVertex );
@@ -539,11 +539,11 @@ 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) ;
   void SetPreCADOptionValue(const std::string& optionName,
-                            const std::string& optionValue) throw (std::invalid_argument);
-  std::string GetOptionValue(const std::string& optionName, bool* isDefault=0) const throw (std::invalid_argument);
-  std::string GetPreCADOptionValue(const std::string& optionName, bool* isDefault=0) const throw (std::invalid_argument);
+                            const std::string& optionValue) ;
+  std::string GetOptionValue(const std::string& optionName, bool* isDefault=0) const ;
+  std::string GetPreCADOptionValue(const std::string& optionName, bool* isDefault=0) const ;
   void ClearOption(const std::string& optionName);
   void ClearPreCADOption(const std::string& optionName);
   TOptionValues        GetOptionValues()       const;
@@ -555,9 +555,9 @@ public:
   std::string GetOption(const std::string& optionName) const;
   std::string GetPreCADOption(const std::string& optionName) const;
 
-  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) ;
 
   /*!
     * Sets the file for export resulting mesh in GMF format

diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
index 648bd789516c701301b99fee414852af8811c395..e629db3a748aab23a7161e28acb4a96dab785d7d 100644 (file)
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx
@@ -905,7 +905,7 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeProximityRatio()
 }
 
 //=============================================================================
-void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception) {
+void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal)  {
   ASSERT(myBaseImpl);
   if (theVal < 0 || theVal > 100)
     THROW_SALOME_CORBA_EXCEPTION( "Invalid verbosity level",SALOME::BAD_PARAM );
@@ -981,7 +981,7 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseDeprecatedPatchMesher()
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfPointsPerPatch( CORBA::Long nb ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfPointsPerPatch( CORBA::Long nb ) 
 {
   if ( GetMaxNumberOfPointsPerPatch() != nb )
   {
@@ -1003,7 +1003,7 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetMaxNumberOfPointsPerPatch()
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfThreads( CORBA::Long nb ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfThreads( CORBA::Long nb ) 
 {
   if ( GetMaxNumberOfThreads() != nb )
   {
@@ -1085,7 +1085,7 @@ bool BLSURFPlugin_Hypothesis_i::GetDebug()
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetPeriodicTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetPeriodicTolerance( CORBA::Double tol ) 
 {
   bool isDefault;
   if ( GetImpl()->GetPreCADOptionValue("periodic_tolerance",&isDefault) != SMESH_Comment( tol ))
@@ -1103,7 +1103,7 @@ void BLSURFPlugin_Hypothesis_i::SetPeriodicTolerance( CORBA::Double tol ) throw
   }
 }
 //=============================================================================
-double BLSURFPlugin_Hypothesis_i::GetPeriodicTolerance() throw (SALOME::SALOME_Exception)
+double BLSURFPlugin_Hypothesis_i::GetPeriodicTolerance() 
 {
   try{
     return this->GetImpl()->GetPeriodicTolerance();
@@ -1117,7 +1117,7 @@ double BLSURFPlugin_Hypothesis_i::GetPeriodicTolerance() throw (SALOME::SALOME_E
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetRequiredEntities( const char* howToTreat ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetRequiredEntities( const char* howToTreat ) 
 {
   if ( GetImpl()->GetRequiredEntities() != howToTreat )
   {
@@ -1139,7 +1139,7 @@ char* BLSURFPlugin_Hypothesis_i::GetRequiredEntities()
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetSewingTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetSewingTolerance( CORBA::Double tol ) 
 {
   bool isDefault;
   if ( GetImpl()->GetPreCADOptionValue("sewing_tolerance",&isDefault) != SMESH_Comment( tol ))
@@ -1157,7 +1157,7 @@ void BLSURFPlugin_Hypothesis_i::SetSewingTolerance( CORBA::Double tol ) throw (S
   }
 }
 //=============================================================================
-CORBA::Double BLSURFPlugin_Hypothesis_i::GetSewingTolerance() throw (SALOME::SALOME_Exception)
+CORBA::Double BLSURFPlugin_Hypothesis_i::GetSewingTolerance() 
 {
   try
   {
@@ -1172,7 +1172,7 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetSewingTolerance() throw (SALOME::SAL
 }
 //=============================================================================
 
-void BLSURFPlugin_Hypothesis_i::SetTags( const char* howToTreat ) throw (SALOME::SALOME_Exception)
+void BLSURFPlugin_Hypothesis_i::SetTags( const char* howToTreat ) 
 {
   if ( GetImpl()->GetTags() != howToTreat )
   {
@@ -1346,7 +1346,7 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() {
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   try {
     std::string name( optionName );
@@ -1458,7 +1458,7 @@ void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const cha
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValue(const char* optionName, const char* optionValue)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   bool valueChanged = false;
   try {
@@ -1537,7 +1537,7 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValue(const char* optionName, con
 
 //=============================================================================
 
-char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception) {
+char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName)  {
   ASSERT(myBaseImpl);
   try {
     bool isDefault;
@@ -1552,7 +1552,7 @@ char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) throw (S
 
 //=============================================================================
 
-char* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValue(const char* optionName) throw (SALOME::SALOME_Exception) {
+char* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValue(const char* optionName)  {
   ASSERT(myBaseImpl);
   try {
     bool isDefault;
@@ -1662,7 +1662,7 @@ BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAdvancedOptionValues()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   for (CORBA::ULong i = 0; i < options.length(); ++i) {
     string name_value_type = options[i].in();
@@ -1690,7 +1690,7 @@ void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   for ( CORBA::ULong i = 0; i < options.length(); ++i) {
     string name_value_type = options[i].in();
@@ -1750,7 +1750,7 @@ void BLSURFPlugin_Hypothesis_i::SetAdvancedOptionValues(const BLSURFPlugin::stri
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetAdvancedOption(const char* optionsAndValues)
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ( !optionsAndValues ) return;
 
@@ -1829,7 +1829,7 @@ char* BLSURFPlugin_Hypothesis_i::GetPreCADOption(const char* optionName)
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   if ( !entry || !entry[0] )
     THROW_SALOME_CORBA_EXCEPTION( "SetSizeMapEntry(): empty geom entry", SALOME::BAD_PARAM );
@@ -1855,7 +1855,7 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* s
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   bool valueChanged = false;
   std::ostringstream sizeMapFunction;
@@ -1886,7 +1886,7 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM:
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   bool valueChanged = false;
   try {
@@ -1914,7 +1914,7 @@ void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char*
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const char* att_entry, CORBA::Double StartSize, CORBA::Double EndSize, CORBA::Double ActionRadius, CORBA::Double ConstantRadius) //TODO ?? finir
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
   //bool valueChanged = false;
@@ -1938,7 +1938,7 @@ void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const
 
 //=============================================================================
 
-char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception) {
+char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry)  {
   ASSERT(myBaseImpl);
   try {
     return CORBA::string_dup(this->GetImpl()->GetSizeMapEntry(entry).c_str());
@@ -1957,7 +1957,7 @@ char* BLSURFPlugin_Hypothesis_i::GetSizeMapEntry(const char* entry) throw (SALOM
 
 //=============================================================================
 
-char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry) throw (SALOME::SALOME_Exception) {
+char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry)  {
   ASSERT(myBaseImpl);
   try {
     return CORBA::string_dup(this->GetImpl()->GetAttractorEntry(entry).c_str());
@@ -1979,7 +1979,7 @@ char* BLSURFPlugin_Hypothesis_i::GetAttractorEntry(const char* entry) throw (SAL
 // // TODO coder cette fonction (utilis??e pour savoir si la valeur a chang??
 // // A finir pour le dump
 // char* BLSURFPlugin_Hypothesis_i::GetClassAttractorEntry(const char* entry)
-//   throw (SALOME::SALOME_Exception)
+//   
 // {
 //   ASSERT(myBaseImpl);
 //   try {
@@ -2085,7 +2085,7 @@ BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams()
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
   for ( CORBA::ULong i = 0; i < sizeMaps.length(); ++i) {
     string entry_sizemap = sizeMaps[i].in();
@@ -2112,7 +2112,7 @@ void BLSURFPlugin_Hypothesis_i::ClearSizeMaps() {
 //=============================================================================
 
 void BLSURFPlugin_Hypothesis_i::SetSizeMap(const GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
   string entry;
@@ -2240,10 +2240,10 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry,
   void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj)
   {}
 
-  void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception)
+  void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  
   {}
 
-  char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception)
+  char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry)  
   {}
 
   void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry)
@@ -2592,7 +2592,7 @@ void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices() {
  * Set/get/unset an enforced vertex on face - OBSOLETE
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-                                                  CORBA::Double z) throw (SALOME::SALOME_Exception) {
+                                                  CORBA::Double z)  {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2626,7 +2626,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace,
  * Set/get/unset an enforced vertex with name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-                                                       CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) {
+                                                       CORBA::Double z, const char* theVertexName)  {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2661,7 +2661,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr the
  * Set/get/unset an enforced vertex with geom object on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2725,7 +2725,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theF
  * Set an enforced vertex with group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -2761,7 +2761,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, 
                                                                 const char* theVertexName, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -2796,7 +2796,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Objec
  * Set an enforced vertex with geom entry and group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -2853,7 +2853,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
 // * Are internal enforced vertices used for a face ?
 // */
 //CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace)
-//    throw (SALOME::SALOME_Exception) {
+//     {
 //  ASSERT(myBaseImpl);
 
 //  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2888,7 +2888,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
  * Get the list of all enforced vertices
  */
 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2920,7 +2920,7 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEO
 }
 
 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y,
-                                                    CORBA::Double z) throw (SALOME::SALOME_Exception) {
+                                                    CORBA::Double z)  {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -2952,7 +2952,7 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFac
 }
 
 bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception) {
+   {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -3011,7 +3011,7 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr th
   }
 }
 
-bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception) {
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace)  {
   ASSERT(myBaseImpl);
 
   if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -3046,7 +3046,7 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theF
 /*!
  * Set/get/unset an enforced vertex on face - NEW (no face)
  */
-bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) 
 {
   ASSERT(myBaseImpl);
 
@@ -3060,7 +3060,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertex(CORBA::Double x, CORBA::Double
 /*!
  * Set/get/unset an enforced vertex with name on face
  */
-bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName) 
 {
   try {
     return SetEnforcedVertexEntry("", x, y, z, theVertexName);
@@ -3073,7 +3073,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::D
  * Set/get/unset an enforced vertex with geom object on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
@@ -3108,7 +3108,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theV
  * Set an enforced vertex with group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -3124,7 +3124,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORB
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, 
                                                                 const char* theVertexName, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -3139,7 +3139,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x,
  * Set an enforced vertex with geom entry and group name on face
  */
 bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
@@ -3171,7 +3171,7 @@ bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object
   }
 }
 
-bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) 
 {
   try {
     return UnsetEnforcedVertexEntry("", x, y, z);
@@ -3181,7 +3181,7 @@ bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Dou
 }
 
 bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-  throw (SALOME::SALOME_Exception)
+  
 {
   if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) {
     THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM);
@@ -3211,7 +3211,7 @@ bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr t
   }
 }
 
-bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertices() throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertices() 
 {
   try {
     return UnsetEnforcedVerticesEntry("");
@@ -3230,7 +3230,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry,
                                                        const char* theVertexName,
                                                        const char* theVertexEntry,
                                                        const char* theGroupName)
-  throw (SALOME::SALOME_Exception)
+  
 {
   bool newValue = false;
   if (string(theVertexEntry).empty()) {
@@ -3300,7 +3300,7 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry,
 }
 
 BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry)
-  throw (SALOME::SALOME_Exception)
+  
 {
   try {
     BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList();
@@ -3348,7 +3348,7 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntr
   }
 }
 
-bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexEntry) throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexEntry) 
 {
   ASSERT(myBaseImpl);
 
@@ -3371,7 +3371,7 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntr
 
   return res;
 }
-bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception)
+bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) 
 {
   ASSERT(myBaseImpl);
 
@@ -3446,7 +3446,7 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
  * Enable internal enforced vertices on specific face if requested by user
  *
  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices)
- throw (SALOME::SALOME_Exception)
+ 
  {
  try {
  SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices);
@@ -3456,7 +3456,7 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
  }
 
  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ 
  {
 
  if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) {
@@ -3489,7 +3489,7 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
  }
 
  void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+ 
  {
  ASSERT(myBaseImpl);
  try {
@@ -3509,7 +3509,7 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
 
 /* TODO GROUPS
    char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-   throw (SALOME::SALOME_Exception)
+   
    {
    ASSERT(myBaseImpl);
    try {
@@ -3531,7 +3531,7 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup()
 
 
    void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName)
-   throw (SALOME::SALOME_Exception)
+   
    {
    ASSERT(myBaseImpl);
    try {
@@ -3732,7 +3732,7 @@ BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequenc
 
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
   const GEOM::ListOfGO theSourceVertices;
@@ -3743,7 +3743,7 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
                                                                       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -3795,7 +3795,7 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry,
                                                                const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
-  throw (SALOME::SALOME_Exception)
+  
 {
 
   ASSERT(myBaseImpl);
@@ -3820,12 +3820,12 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFa
     pd << listEntriesTxt.c_str();
     pd << ")";
   }
-  else
+  else                                                                                      
     pd << _this() << ".AddPreCadFacesPeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")";
 }
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
   const GEOM::ListOfGO theSourceVertices;
@@ -3835,7 +3835,7 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
                                                                       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-  throw (SALOME::SALOME_Exception)
+  
 {
   ASSERT(myBaseImpl);
 
@@ -3887,7 +3887,7 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM
 
 void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry,
                                                                const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba)
-  throw (SALOME::SALOME_Exception)
+  
 {
 
   ASSERT(myBaseImpl);

diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
index dd4a5a00b12c0a0f83605a3f366f5c54456d25be..29db931464761f7d1c72886c3b2f694c66cf36ed 100644 (file)
--- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
+++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx
@@ -170,7 +170,7 @@ public:
   CORBA::Double GetVolumeProximityRatio();
 
 
-  void SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception);
+  void SetVerbosity(CORBA::Short theVal);
   CORBA::Short GetVerbosity();
 
   void SetEnforceCadEdgesSize( CORBA::Boolean toEnforce );
@@ -185,10 +185,10 @@ public:
   void SetJacobianRectification( CORBA::Boolean allowRectification );
   CORBA::Boolean GetJacobianRectification();
 
-  void SetMaxNumberOfPointsPerPatch( CORBA::Long nb ) throw (SALOME::SALOME_Exception);
+  void SetMaxNumberOfPointsPerPatch( CORBA::Long nb );
   CORBA::Long GetMaxNumberOfPointsPerPatch();
 
-  void SetMaxNumberOfThreads( CORBA::Long nb ) throw (SALOME::SALOME_Exception);
+  void SetMaxNumberOfThreads( CORBA::Long nb );
   CORBA::Long GetMaxNumberOfThreads();
 
   void SetRespectGeometry( CORBA::Boolean toRespect );
@@ -203,16 +203,16 @@ public:
   void SetDebug( CORBA::Boolean isDebug );
   bool GetDebug();
 
-  void SetPeriodicTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception);
-  double GetPeriodicTolerance() throw (SALOME::SALOME_Exception);
+  void SetPeriodicTolerance( CORBA::Double tol );
+  double GetPeriodicTolerance();
 
-  void SetRequiredEntities( const char* howToTreat ) throw (SALOME::SALOME_Exception);
+  void SetRequiredEntities( const char* howToTreat );
   char* GetRequiredEntities();
 
-  void SetSewingTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception);
-  CORBA::Double GetSewingTolerance() throw (SALOME::SALOME_Exception);
+  void SetSewingTolerance( CORBA::Double tol );
+  CORBA::Double GetSewingTolerance();
 
-  void SetTags( const char* howToTreat ) throw (SALOME::SALOME_Exception);
+  void SetTags( const char* howToTreat );
   char* GetTags();
 
   void SetHyperPatches(const BLSURFPlugin::THyperPatchList& hpl);
@@ -230,10 +230,10 @@ public:
   void SetPreCADDiscardInput(CORBA::Boolean theValue);
   CORBA::Boolean GetPreCADDiscardInput();
 
-  void SetOptionValue(const char* optionName, const char* optionValue) throw (SALOME::SALOME_Exception);
-  void SetPreCADOptionValue(const char* optionName, const char* optionValue) throw (SALOME::SALOME_Exception);
-  char* GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception);
-  char* GetPreCADOptionValue(const char* optionName) throw (SALOME::SALOME_Exception);
+  void SetOptionValue(const char* optionName, const char* optionValue);
+  void SetPreCADOptionValue(const char* optionName, const char* optionValue);
+  char* GetOptionValue(const char* optionName);
+  char* GetPreCADOptionValue(const char* optionName);
 
   void UnsetOption(const char* optionName);
   void UnsetPreCADOption(const char* optionName);
@@ -242,29 +242,29 @@ public:
   BLSURFPlugin::string_array* GetPreCADOptionValues();
   BLSURFPlugin::string_array* GetAdvancedOptionValues();
 
-  void SetOptionValues(const BLSURFPlugin::string_array& options) throw (SALOME::SALOME_Exception);
-  void SetPreCADOptionValues(const BLSURFPlugin::string_array& options) throw (SALOME::SALOME_Exception);
+  void SetOptionValues(const BLSURFPlugin::string_array& options);
+  void SetPreCADOptionValues(const BLSURFPlugin::string_array& options);
   void SetAdvancedOptionValues(const BLSURFPlugin::string_array& options);
-  void SetAdvancedOption(const char* optionsAndValues) throw (SALOME::SALOME_Exception);
+  void SetAdvancedOption(const char* optionsAndValues);
 
   void AddOption(const char* optionName, const char* optionValue);
   void AddPreCADOption(const char* optionName, const char* optionValue);
   char* GetOption(const char* optionName);
   char* GetPreCADOption(const char* optionName);
 
-  void SetSizeMapEntry(const char* entry, const char* sizeMap) throw (SALOME::SALOME_Exception);
+  void SetSizeMapEntry(const char* entry, const char* sizeMap);
 
-  void SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap) throw (SALOME::SALOME_Exception);
+  void SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap);
 
-  char* GetSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception);
+  char* GetSizeMapEntry(const char* entry);
 
   void UnsetEntry(const char* entry);
 
   BLSURFPlugin::string_array* GetSizeMapEntries();
 
-  void SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps) throw (SALOME::SALOME_Exception);
+  void SetSizeMapEntries(const BLSURFPlugin::string_array& sizeMaps);
 
-  void SetSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap) throw (SALOME::SALOME_Exception);
+  void SetSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap);
 
   void SetConstantSizeMap(GEOM::GEOM_Object_ptr GeomObj, CORBA::Double sizeMap);
 
@@ -276,9 +276,9 @@ public:
 
   void UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj);
 
-  void SetAttractorEntry(const char* entry, const char* attractor) throw (SALOME::SALOME_Exception);
+  void SetAttractorEntry(const char* entry, const char* attractor);
 
-  char* GetAttractorEntry(const char* entry) throw (SALOME::SALOME_Exception);
+  char* GetAttractorEntry(const char* entry);
 
   BLSURFPlugin::string_array* GetAttractorEntries();
   
@@ -293,7 +293,7 @@ public:
                           GEOM::GEOM_Object_ptr theAttractor);
 
   void UnsetAttractorEntry(const char* entry, const char* attractor);
-  void SetClassAttractorEntry(const char* entry, const char* att_entry, CORBA::Double StartSize, CORBA::Double EndSize, CORBA::Double ActionRadius, CORBA::Double ConstantRadius)  throw (SALOME::SALOME_Exception);
+  void SetClassAttractorEntry(const char* entry, const char* att_entry, CORBA::Double StartSize, CORBA::Double EndSize, CORBA::Double ActionRadius, CORBA::Double ConstantRadius);
 
   BLSURFPlugin::TAttParamsMap* GetAttractorParams();
   
@@ -303,9 +303,9 @@ public:
 
    void UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj);
 
-   void SetCustomSizeMapEntry(const char* entry,const char* sizeMap )  throw (SALOME::SALOME_Exception);
+   void SetCustomSizeMapEntry(const char* entry,const char* sizeMap );
 
-   char* GetCustomSizeMapEntry(const char* entry)  throw (SALOME::SALOME_Exception);
+   char* GetCustomSizeMapEntry(const char* entry);
 
    BLSURFPlugin::string_array* GetCustomSizeMapEntries();
    */
@@ -330,58 +330,58 @@ public:
    */
   // OBSOLETE
   bool SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName, const char* theGroupName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
-      throw (SALOME::SALOME_Exception);
+      ;
 
-  BLSURFPlugin::TEnfVertexList* GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception);
+  BLSURFPlugin::TEnfVertexList* GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) ;
 
   bool UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex)
-      throw (SALOME::SALOME_Exception);
-  bool UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception);
+      ;
+  bool UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) ;
 
   // NEW - no face
   bool AddEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool AddEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName, const char* theGroupName)
-      throw (SALOME::SALOME_Exception);
+      ;
   bool AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName)
-      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);
-  bool RemoveEnforcedVertices() throw (SALOME::SALOME_Exception);
+      ;
+  bool RemoveEnforcedVertices() ;
 
   /*!
    * Set/get/unset an enforced vertex on geom object given by entry
    */
   bool SetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x = 0, CORBA::Double y = 0, CORBA::Double z = 0,
       const char* theVertexName = "", const char* theVertexEntry = "", const char* theGroupName = "")
-      throw (SALOME::SALOME_Exception);
+      ;
 
-  BLSURFPlugin::TEnfVertexList* GetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception);
+  BLSURFPlugin::TEnfVertexList* GetEnforcedVerticesEntry(const char* theFaceEntry) ;
 
   bool UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z,
-      const char* theVertexEntry = "") throw (SALOME::SALOME_Exception);
-  bool UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception);
+      const char* theVertexEntry = "") ;
+  bool UnsetEnforcedVerticesEntry(const char* theFaceEntry) ;
 
   /*!
    * To add internal vertices as enforced vertices
@@ -392,11 +392,11 @@ public:
   char* GetInternalEnforcedVertexAllFacesGroup();
 
 // Enable internal enforced vertices on specific face if requested by user
-//  void SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices) throw (SALOME::SALOME_Exception);
-//  void SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName = "") throw (SALOME::SALOME_Exception);
-//  void SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName = "") throw (SALOME::SALOME_Exception);
-//  CORBA::Boolean GetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception);
-//  CORBA::Boolean GetInternalEnforcedVertexEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception);
+//  void SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices) ;
+//  void SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName = "") ;
+//  void SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName = "") ;
+//  CORBA::Boolean GetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace) ;
+//  CORBA::Boolean GetInternalEnforcedVertexEntry(const char* theFaceEntry) ;
   
   ///////////////////////
   // PERIODICITY       //
@@ -410,26 +410,26 @@ public:
   BLSURFPlugin::TPeriodicityList* PreCadVectorToSequence(const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector& preCadPeriodicityVector);
 
   void AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   void AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2,
       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   void AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry,
       const BLSURFPlugin::TEntryList& theSourceVerticesEntries, const BLSURFPlugin::TEntryList& theTargetVerticesEntries)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   void AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   void AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2,
       const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   void AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry,
       const BLSURFPlugin::TEntryList& theSourceVerticesEntries, const BLSURFPlugin::TEntryList& theTargetVerticesEntries)
-      throw (SALOME::SALOME_Exception);
+      ;
 
   ///////////////////////