src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
  24 //  File   : StdMeshers_NumberOfSegments_i.cxx
  25 //           Moved here from SMESH_NumberOfSegments_i.cxx
  26 //  Author : Paul RASCLE, EDF
  27 //  Module : SMESH
  28 //
  29 #include "StdMeshers_NumberOfSegments_i.hxx"
  30 #include "SMESH_Gen_i.hxx"
  31 #include "SMESH_Gen.hxx"
  32 #include "SMESH_PythonDump.hxx"
  33
  34 #include "Utils_CorbaException.hxx"
  35 #include "utilities.h"
  36
  37 #include <TCollection_AsciiString.hxx>
  38
  39 using namespace std;
  40 //=============================================================================
  41 /*!
  42  *  StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i
  43  *
  44  *  Constructor
  45  */
  46 //=============================================================================
  47
  48 StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i( PortableServer::POA_ptr thePOA,
  49                                                     int                     theStudyId,
  50                                                     ::SMESH_Gen*            theGenImpl )
  51      : SALOME::GenericObj_i( thePOA ),
  52        SMESH_Hypothesis_i( thePOA )
  53 {
  54   MESSAGE( "StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i" );
  55   myBaseImpl = new ::StdMeshers_NumberOfSegments( theGenImpl->GetANewId(),
  56                                              theStudyId,
  57                                              theGenImpl );
  58 }
  59
  60 //=============================================================================
  61 /*!
  62  *  StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i
  63  *
  64  *  Destructor
  65  */
  66 //=============================================================================
  67
  68 StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i()
  69 {
  70   MESSAGE( "StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i" );
  71 }
  72
  73 //=============================================================================
  74 /*!
  75  *  StdMeshers_NumberOfSegments_i::BuildDistribution
  76  *
  77  *  Builds point distribution according to passed function
  78  */
  79 //=============================================================================
  80 SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func,
  81                                                                            CORBA::Long nbSeg,
  82                                                                            CORBA::Long conv )
  83   throw ( SALOME::SALOME_Exception )
  84 {
  85   ASSERT( myBaseImpl );
  86   try
  87   {
  88     SMESH::double_array_var aRes = new SMESH::double_array();
  89     const std::vector<double>& res = this->GetImpl()->BuildDistributionExpr( func, nbSeg, conv );
  90     aRes->length( res.size() );
  91     for (size_t i = 0; i < res.size(); i++)
  92       aRes[i] = res[i];
  93     return aRes._retn();
  94   }
  95   catch( SALOME_Exception& S_ex )
  96   {
  97     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
  98   }
  99 }
 100
 101 SMESH::double_array*
 102 StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
 103                                                      CORBA::Long                nbSeg,
 104                                                      CORBA::Long                conv )
 105   throw ( SALOME::SALOME_Exception )
 106 {
 107   ASSERT( myBaseImpl );
 108
 109   std::vector<double> tbl( func.length() );
 110   for ( size_t i = 0; i < tbl.size(); i++ )
 111     tbl[i] = func[i];
 112
 113   try
 114   {
 115     SMESH::double_array_var   aRes = new SMESH::double_array();
 116     const std::vector<double>& res = this->GetImpl()->BuildDistributionTab( tbl, nbSeg, conv );
 117     aRes->length( res.size() );
 118     for (size_t i = 0; i < res.size(); i++)
 119       aRes[i] = res[i];
 120     return aRes._retn();
 121   }
 122   catch( SALOME_Exception& S_ex )
 123   {
 124     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
 125   }
 126 }
 127
 128 //=============================================================================
 129 /*!
 130  *  StdMeshers_NumberOfSegments_i::SetNumberOfSegments
 131  *
 132  *  Set number of segments
 133  */
 134 //=============================================================================
 135
 136 void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
 137      throw ( SALOME::SALOME_Exception )
 138 {
 139   ASSERT( myBaseImpl );
 140   try {
 141     this->GetImpl()->SetNumberOfSegments( theSegmentsNumber );
 142   }
 143   catch (SALOME_Exception& S_ex) {
 144     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 145                                   SALOME::BAD_PARAM );
 146   }
 147
 148   // Update Python script
 149   SMESH::TPythonDump() << _this() << ".SetNumberOfSegments( " << SMESH::TVar(theSegmentsNumber) << " )";
 150 }
 151
 152 //=============================================================================
 153 /*!
 154  *  StdMeshers_NumberOfSegments_i::GetNumberOfSegments
 155  *
 156  *  Get number of segments
 157  */
 158 //=============================================================================
 159
 160 CORBA::Long StdMeshers_NumberOfSegments_i::GetNumberOfSegments()
 161 {
 162   ASSERT( myBaseImpl );
 163   return this->GetImpl()->GetNumberOfSegments();
 164 }
 165
 166 //=============================================================================
 167 /*!
 168  *  StdMeshers_NumberOfSegments_i::SetReversedEdges
 169  *
 170  *  Set edges to reverse
 171  */
 172 //=============================================================================
 173
 174 void StdMeshers_NumberOfSegments_i::SetReversedEdges( const SMESH::long_array& theIds )
 175 {
 176   ASSERT( myBaseImpl );
 177   try {
 178     std::vector<int> ids( theIds.length() );
 179     CORBA::Long iEnd = theIds.length();
 180     for ( CORBA::Long i = 0; i < iEnd; i++ )
 181       ids[ i ] = theIds[ i ];
 182
 183     this->GetImpl()->SetReversedEdges( ids );
 184   }
 185   catch ( SALOME_Exception& S_ex ) {
 186     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 187                                   SALOME::BAD_PARAM );
 188   }
 189
 190   // Update Python script
 191   SMESH::TPythonDump() << _this() << ".SetReversedEdges( " << theIds << " )";
 192 }
 193
 194 //=============================================================================
 195 /*!
 196  *  StdMeshers_NumberOfSegments_i::SetObjectEntry
 197  *
 198  *  Set the Entry for the Main Object
 199  */
 200 //=============================================================================
 201
 202 void StdMeshers_NumberOfSegments_i::SetObjectEntry( const char* theEntry )
 203 {
 204   ASSERT( myBaseImpl );
 205   string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
 206   try {
 207     this->GetImpl()->SetObjectEntry( entry.c_str() );
 208   }
 209   catch ( SALOME_Exception& S_ex ) {
 210     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 211                                   SALOME::BAD_PARAM );
 212   }
 213   // Update Python script
 214   SMESH::TPythonDump() << _this() << ".SetObjectEntry( \"" << entry.c_str() << "\" )";
 215 }
 216
 217 //=============================================================================
 218 /*!
 219  *  StdMeshers_NumberOfSegments_i::GetObjectEntry
 220  *
 221  *  Set the Entry for the Main Object
 222  */
 223 //=============================================================================
 224
 225 char* StdMeshers_NumberOfSegments_i::GetObjectEntry()
 226 {
 227   ASSERT( myBaseImpl );
 228
 229   const char* entry;
 230   try {
 231     entry = this->GetImpl()->GetObjectEntry();
 232   }
 233   catch ( SALOME_Exception& S_ex ) {
 234     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 235                                   SALOME::BAD_PARAM );
 236   }
 237   return CORBA::string_dup( entry );
 238 }
 239
 240 //=============================================================================
 241 /*!
 242  *  StdMeshers_NumberOfSegments_i::GetReversedEdges
 243  *
 244  *  Get reversed edges
 245  */
 246 //=============================================================================
 247
 248 SMESH::long_array* StdMeshers_NumberOfSegments_i::GetReversedEdges()
 249 {
 250   MESSAGE( "StdMeshers_NumberOfSegments_i::GetReversedEdges" );
 251   ASSERT( myBaseImpl );
 252   SMESH::long_array_var anArray = new SMESH::long_array;
 253   std::vector<int> ids = this->GetImpl()->GetReversedEdges();
 254   anArray->length( ids.size() );
 255   for ( size_t i = 0; i < ids.size(); i++)
 256     anArray [ i ] = ids [ i ];
 257
 258   return anArray._retn();
 259 }
 260
 261 //=============================================================================
 262 /*!
 263  */
 264 //=============================================================================
 265
 266 void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
 267   throw ( SALOME::SALOME_Exception )
 268 {
 269   ASSERT( myBaseImpl );
 270   try {
 271     CORBA::Long oldType = (CORBA::Long) this->GetImpl()->GetDistrType();
 272
 273     this->GetImpl()->SetDistrType( (::StdMeshers_NumberOfSegments::DistrType) typ );
 274
 275     // Update Python script
 276     if ( oldType != typ )
 277       SMESH::TPythonDump() << _this() << ".SetDistrType( " << typ << " )";
 278   }
 279   catch ( SALOME_Exception& S_ex ) {
 280     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 281                                   SALOME::BAD_PARAM );
 282   }
 283 }
 284
 285 //=============================================================================
 286 /*!
 287  */
 288 //=============================================================================
 289
 290 CORBA::Long StdMeshers_NumberOfSegments_i::GetDistrType()
 291 {
 292   ASSERT( myBaseImpl );
 293   return this->GetImpl()->GetDistrType();
 294 }
 295
 296 //=============================================================================
 297 /*!
 298  *  StdMeshers_NumberOfSegments_i::SetScaleFactor
 299  *
 300  *  Set scalar factor
 301  */
 302 //=============================================================================
 303
 304 void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
 305      throw ( SALOME::SALOME_Exception )
 306 {
 307   ASSERT( myBaseImpl );
 308   try {
 309     this->GetImpl()->SetScaleFactor( theScaleFactor );
 310     // Update Python script
 311     SMESH::TPythonDump() << _this() << ".SetScaleFactor( " << SMESH::TVar(theScaleFactor) << " )";
 312   }
 313   catch ( SALOME_Exception& S_ex ) {
 314     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 315                                   SALOME::BAD_PARAM );
 316   }
 317 }
 318
 319 //=============================================================================
 320 /*!
 321  *  StdMeshers_NumberOfSegments_i::GetScaleFactor
 322  *
 323  *  Get scalar factor
 324  */
 325 //=============================================================================
 326
 327 CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
 328   throw ( SALOME::SALOME_Exception )
 329 {
 330   ASSERT( myBaseImpl );
 331   double scale;
 332   try {
 333     scale = this->GetImpl()->GetScaleFactor();
 334   }
 335   catch ( SALOME_Exception& S_ex ) {
 336     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 337                                   SALOME::BAD_PARAM );
 338   }
 339   return scale;
 340 }
 341
 342 //=============================================================================
 343 /*!
 344  */
 345 //=============================================================================
 346
 347 void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
 348   throw ( SALOME::SALOME_Exception )
 349 {
 350   ASSERT( myBaseImpl );
 351   std::vector<double> tbl( table.length() );
 352   for ( CORBA::ULong i = 0; i < table.length(); i++)
 353     tbl[i] = table[i];
 354   try {
 355     this->GetImpl()->SetTableFunction( tbl );
 356     // Update Python script
 357     SMESH::TPythonDump() << _this() << ".SetTableFunction( " << table << " )";
 358   }
 359   catch ( SALOME_Exception& S_ex ) {
 360     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 361                                   SALOME::BAD_PARAM );
 362   }
 363 }
 364
 365 //=============================================================================
 366 /*!
 367  */
 368 //=============================================================================
 369
 370 SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
 371   throw ( SALOME::SALOME_Exception )
 372 {
 373   ASSERT( myBaseImpl );
 374   const std::vector<double>* tbl;
 375   try {
 376     tbl = &this->GetImpl()->GetTableFunction();
 377   }
 378   catch ( SALOME_Exception& S_ex ) {
 379     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
 380   }
 381   SMESH::double_array_var aRes = new SMESH::double_array();
 382   aRes->length(tbl->size());
 383   for ( size_t i = 0; i < tbl->size(); i++ )
 384     aRes[i] = (*tbl)[i];
 385   return aRes._retn();
 386 }
 387
 388 //=============================================================================
 389 /*!
 390  */
 391 //=============================================================================
 392
 393 void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
 394   throw ( SALOME::SALOME_Exception )
 395 {
 396   ASSERT( myBaseImpl );
 397   try {
 398     this->GetImpl()->SetExpressionFunction( expr );
 399     // Update Python script
 400     SMESH::TPythonDump() << _this() << ".SetExpressionFunction( '" << expr << "' )";
 401   }
 402   catch ( SALOME_Exception& S_ex ) {
 403     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 404                                   SALOME::BAD_PARAM );
 405   }
 406 }
 407
 408 //=============================================================================
 409 /*!
 410  */
 411 //=============================================================================
 412
 413 char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
 414   throw ( SALOME::SALOME_Exception )
 415 {
 416   ASSERT( myBaseImpl );
 417   const char* expr;
 418   try {
 419     expr = this->GetImpl()->GetExpressionFunction();
 420   }
 421   catch ( SALOME_Exception& S_ex ) {
 422     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 423                                   SALOME::BAD_PARAM );
 424   }
 425   return CORBA::string_dup(expr);
 426 }
 427
 428 //=============================================================================
 429 /*!
 430  */
 431 //=============================================================================
 432
 433 void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
 434   throw ( SALOME::SALOME_Exception )
 435 {
 436   ASSERT( myBaseImpl );
 437   try {
 438     this->GetImpl()->SetConversionMode( conv );
 439     // Update Python script
 440     SMESH::TPythonDump() << _this() << ".SetConversionMode( " << conv << " )";
 441   }
 442   catch ( SALOME_Exception& S_ex ) {
 443     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 444                                   SALOME::BAD_PARAM );
 445   }
 446 }
 447
 448 //=============================================================================
 449 /*!
 450  */
 451 //=============================================================================
 452
 453 CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode()
 454   throw ( SALOME::SALOME_Exception )
 455 {
 456   ASSERT( myBaseImpl );
 457   int conv;
 458   try {
 459     conv = this->GetImpl()->ConversionMode();
 460   }
 461   catch ( SALOME_Exception& S_ex ) {
 462     THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
 463                                   SALOME::BAD_PARAM );
 464   }
 465   return conv;
 466 }
 467
 468 //=============================================================================
 469 /*!
 470  *  StdMeshers_NumberOfSegments_i::GetImpl
 471  *
 472  *  Get implementation
 473  */
 474 //=============================================================================
 475
 476 ::StdMeshers_NumberOfSegments* StdMeshers_NumberOfSegments_i::GetImpl()
 477 {
 478   return ( ::StdMeshers_NumberOfSegments* )myBaseImpl;
 479 }
 480
 481 //================================================================================
 482 /*!
 483  * \brief Verify whether hypothesis supports given entity type
 484   * \param type - dimension (see SMESH::Dimension enumeration)
 485   * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
 486  *
 487  * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
 488  */
 489 //================================================================================
 490 CORBA::Boolean StdMeshers_NumberOfSegments_i::IsDimSupported( SMESH::Dimension type )
 491 {
 492   return type == SMESH::DIM_1D;
 493 }
 494
 495 //================================================================================
 496 /*!
 497  * \brief Return method name corresponding to index of variable parameter
 498  */
 499 //================================================================================
 500
 501 std::string StdMeshers_NumberOfSegments_i::getMethodOfParameter(const int paramIndex, int ) const
 502 {
 503   return paramIndex == 0 ? "SetNumberOfSegments" : "SetScaleFactor";
 504 }