bos #20256: [CEA 18523] Porting SMESH to int 64 bits

[modules/smesh.git] / src / StdMeshers / StdMeshers_NumberOfSegments.cxx

diff --git a/src/StdMeshers/StdMeshers_NumberOfSegments.cxx b/src/StdMeshers/StdMeshers_NumberOfSegments.cxx
index 5ba6e47d9d31a3cf1c3baa452f834274455ff0ee..eb125cae23c5b35223a604f6c9c6b7a94f7b5569 100644 (file)
--- a/src/StdMeshers/StdMeshers_NumberOfSegments.cxx
+++ b/src/StdMeshers/StdMeshers_NumberOfSegments.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -60,7 +60,7 @@ const double PRECISION = 1e-7;
 
 StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int         hypId,
                                                          SMESH_Gen * gen)
-  : SMESH_Hypothesis(hypId, gen),
+  : StdMeshers_Reversible1D(hypId, gen),
     _numberOfSegments(15),//issue 19923
     _distrType(DT_Regular),
     _scaleFactor(1.),
@@ -87,7 +87,6 @@ StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
 //=============================================================================
 const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
-  throw ( SALOME_Exception )
 {
   if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -98,7 +97,6 @@ const vector<double>&
 StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
                                                    int nbSeg,
                                                    int conv )
-  throw ( SALOME_Exception )
 {
   if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
     _distr.resize( 0 );
@@ -111,10 +109,9 @@ StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
  */
 //=============================================================================
 
-void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
-throw(SALOME_Exception)
+void StdMeshers_NumberOfSegments::SetNumberOfSegments(smIdType segmentsNumber)
 {
-  int oldNumberOfSegments = _numberOfSegments;
+  smIdType oldNumberOfSegments = _numberOfSegments;
   if (segmentsNumber <= 0)
     throw SALOME_Exception(LOCALIZED("number of segments must be positive"));
   _numberOfSegments = segmentsNumber;
@@ -129,7 +126,7 @@ throw(SALOME_Exception)
  */
 //=============================================================================
 
-int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
+smIdType StdMeshers_NumberOfSegments::GetNumberOfSegments() const
 {
   return _numberOfSegments;
 }
@@ -141,7 +138,6 @@ int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
-  throw(SALOME_Exception)
 {
   if (typ < DT_Regular || typ > DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
@@ -171,7 +167,6 @@ StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
-  throw(SALOME_Exception)
 {
   if (scaleFactor < PRECISION)
     throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
@@ -197,7 +192,6 @@ void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
 //================================================================================
 
 double StdMeshers_NumberOfSegments::GetScaleFactor() const
-  throw(SALOME_Exception)
 {
   if (_distrType != DT_Scale)
     throw SALOME_Exception(LOCALIZED("not a scale distribution"));
@@ -211,7 +205,6 @@ double StdMeshers_NumberOfSegments::GetScaleFactor() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
-  throw(SALOME_Exception)
 {
   if (_distrType != DT_TabFunc)
     _distrType = DT_TabFunc;
@@ -233,7 +226,7 @@ void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
         OCC_CATCH_SIGNALS;
         val = pow( 10.0, val );
       }
-      catch(Standard_Failure) {
+      catch(Standard_Failure&) {
         throw SALOME_Exception( LOCALIZED( "invalid value"));
         return;
       }
@@ -276,7 +269,6 @@ void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
 //================================================================================
 
 const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
-  throw(SALOME_Exception)
 {
   if (_distrType != DT_TabFunc)
     throw SALOME_Exception(LOCALIZED("not a table function distribution"));
@@ -327,7 +319,7 @@ bool process( const TCollection_AsciiString& str, int convMode,
     OCC_CATCH_SIGNALS;
     myExpr = ExprIntrp_GenExp::Create();
     myExpr->Process( str.ToCString() );
-  } catch(Standard_Failure) {
+  } catch(Standard_Failure&) {
     parsed_ok = false;
   }
 
@@ -380,7 +372,6 @@ bool process( const TCollection_AsciiString& str, int convMode,
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
-  throw(SALOME_Exception)
 {
   if (_distrType != DT_ExprFunc)
     _distrType = DT_ExprFunc;
@@ -402,7 +393,6 @@ void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
 std::string
 StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
                                                       const int          convMode)
-    throw (SALOME_Exception)
 {
   // remove white spaces
   TCollection_AsciiString str((Standard_CString)expr.c_str());
@@ -442,7 +432,6 @@ StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
 //================================================================================
 
 const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
-  throw(SALOME_Exception)
 {
   if (_distrType != DT_ExprFunc)
     throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
@@ -456,7 +445,6 @@ const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
 //================================================================================
 
 void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
-  throw(SALOME_Exception)
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
@@ -475,7 +463,6 @@ void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
 //================================================================================
 
 int StdMeshers_NumberOfSegments::ConversionMode() const
-  throw(SALOME_Exception)
 {
 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
@@ -490,7 +477,7 @@ int StdMeshers_NumberOfSegments::ConversionMode() const
 
 ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
 {
-  int listSize = _edgeIDs.size();
+  size_t listSize = _edgeIDs.size();
   save << _numberOfSegments << " " << (int)_distrType;
   switch (_distrType)
   {
@@ -515,7 +502,7 @@ ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
 
   if ( _distrType != DT_Regular && listSize > 0 ) {
     save << " " << listSize;
-    for ( int i = 0; i < listSize; i++ )
+    for ( size_t i = 0; i < listSize; i++ )
       save << " " << _edgeIDs[i];
     save << " " << _objEntry;
   }
@@ -546,12 +533,12 @@ istream & StdMeshers_NumberOfSegments::LoadFrom(istream & load)
   //    we wait here the scale factor, which is double.
   // 2. If the hypothesis is stored in new format
   //    (nb.segments, distr.type, some other params.),
-  //    we wait here the ditribution type, which is integer
+  //    we wait here the distribution type, which is integer
   double scale_factor;
   isOK = static_cast<bool>(load >> scale_factor);
   a = (int)scale_factor;
 
-  // try to interpret ditribution type,
+  // try to interpret distribution type,
   // supposing that this hypothesis was written in the new format
   if (isOK)
   {
@@ -721,19 +708,3 @@ bool StdMeshers_NumberOfSegments::SetParametersByDefaults(const TDefaults&  dflt
 {
   return (_numberOfSegments = dflts._nbSegments );
 }
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-void StdMeshers_NumberOfSegments::SetReversedEdges( std::vector<int>& ids )
-{
-  if ( ids != _edgeIDs ) {
-    _edgeIDs = ids;
-
-    NotifySubMeshesHypothesisModification();
-  }
-}
-