src/SyrComponent/SyrComponent_Impl.cxx

   1 // Copyright (C) 2007-2022  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 //  SuperVisionTest SyrComponent : example of component performing some mathinatical operations
  24 //  File   : SyrComponent_Impl.cxx
  25 //  Author : Jean Rahuel, CEA
  26 //  Module : SuperVisionTest
  27 //
  28 #include <stdio.h>
  29 #ifndef WIN32
  30 #include <unistd.h>
  31 #else
  32 #include <process.h>
  33 #endif
  34 #include <fstream>
  35 #include <sstream>
  36 #include <string>
  37
  38 #include "COMPONENT_version.h"
  39 #include "SyrComponent_Impl.hxx"
  40 #include "Adder_Impl.hxx"
  41
  42 using namespace std;
  43
  44 SyrComponent_Impl::SyrComponent_Impl( CORBA::ORB_ptr orb ,
  45                                       PortableServer::POA_ptr poa ,
  46                                       PortableServer::ObjectId * contId ,
  47                                       const char *instanceName ,
  48                                       const char *interfaceName ,
  49                                       const bool kactivate , bool withRegistry ) :
  50   Engines_Component_i(orb, poa, contId, instanceName, interfaceName,true/*notif is true here for message*/,withRegistry) {
  51   MESSAGE("SyrComponent_Impl::SyrComponent_Impl this " << hex << this << dec
  52           << "activate object instanceName("
  53           << instanceName << ") interfaceName(" << interfaceName << ")" )
  54   if ( kactivate ) {
  55     _thisObj = this ;
  56     _id = _poa->activate_object(_thisObj);
  57   }
  58 }
  59
  60 SyrComponent_Impl::SyrComponent_Impl() {
  61 }
  62
  63 SyrComponent_Impl::~SyrComponent_Impl() {
  64 }
  65
  66 char* SyrComponent_Impl::getVersion()
  67 {
  68 #if COMPONENT_DEVELOPMENT
  69   return CORBA::string_dup(COMPONENT_VERSION_STR"dev");
  70 #else
  71   return CORBA::string_dup(COMPONENT_VERSION_STR);
  72 #endif
  73 }
  74
  75 CORBA::Long SyrComponent_Impl::C_ISEVEN( CORBA::Long anInteger ) {
  76   bool RetVal ;
  77   beginService( " SyrComponent_Impl::C_ISEVEN" );
  78   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_ISEVEN is Computing");
  79 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
  80   int S = 1 ;
  81 #ifndef WIN32
  82   while ( S ) {
  83     S = sleep( S ) ;
  84   }
  85 #else
  86   Sleep(S*1000);
  87 #endif
  88   RetVal = ( anInteger & 1 ) == 0 ;
  89   endService( " SyrComponent_Impl::C_ISEVEN"  );
  90   return RetVal ;
  91 }
  92
  93 CORBA::Long SyrComponent_Impl::C_ISONE( CORBA::Long anOddInteger ) {
  94   bool RetVal ;
  95   beginService( " SyrComponent_Impl::C_ISONE" );
  96   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_ISONE is Computing");
  97 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
  98   int S = 1 ;
  99 #ifndef WIN32
 100   while ( S ) {
 101     S = sleep( S ) ;
 102   }
 103 #else
 104   Sleep(S*1000);
 105 #endif
 106   RetVal = ( anOddInteger == 1 ) ;
 107   endService( " SyrComponent_Impl::C_ISONE"  );
 108   return RetVal ;
 109 }
 110
 111 CORBA::Long SyrComponent_Impl::C_M3( CORBA::Long anOddInteger ) {
 112   beginService( " SyrComponent_Impl::C_M3" );
 113   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_M3 is Computing");
 114 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 115   int S = 1 ;
 116 #ifndef WIN32
 117   while ( S ) {
 118     S = sleep( S ) ;
 119   }
 120 #else
 121   Sleep(S*1000);
 122 #endif  endService( " SyrComponent_Impl::C_M3"  );
 123   if ( C_ISEVEN( anOddInteger ) )
 124     return 0 ;
 125   return ( 3*anOddInteger ) ;
 126 }
 127
 128 CORBA::Long SyrComponent_Impl::C_M3P1( CORBA::Long anOddInteger ) {
 129   beginService( " SyrComponent_Impl::C_M3P1" );
 130   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_M3P1 is Computing");
 131 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 132   int S = 1 ;
 133 #ifndef WIN32
 134   while ( S ) {
 135     S = sleep( S ) ;
 136   }
 137 #else
 138   Sleep(S*1000);
 139 #endif
 140   endService( " SyrComponent_Impl::C_M3P1"  );
 141   if ( C_ISEVEN( anOddInteger ) )
 142     return 0 ;
 143   return ( 3*anOddInteger + 1 ) ;
 144 }
 145
 146 CORBA::Long SyrComponent_Impl::C_DIV2( CORBA::Long anEvenInteger ) {
 147   beginService( " SyrComponent_Impl::C_DIV2" );
 148   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_DIV2 is Computing");
 149 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 150   int S = 1 ;
 151 #ifndef WIN32
 152   while ( S ) {
 153     S = sleep( S ) ;
 154   }
 155 #else
 156   Sleep(S*1000);
 157 #endif
 158   endService( " SyrComponent_Impl::C_DIV2"  );
 159   if ( !C_ISEVEN( anEvenInteger ) )
 160     return 0 ;
 161   return ( anEvenInteger >> 1 ) ;
 162 }
 163
 164 CORBA::Long SyrComponent_Impl::C_INCR( CORBA::Long aCount ) {
 165   beginService( " SyrComponent_Impl::C_INCR" );
 166   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_INCR is Computing");
 167 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 168   int S = 1 ;
 169 #ifndef WIN32
 170   while ( S ) {
 171     S = sleep( S ) ;
 172   }
 173 #else
 174   Sleep(S*1000);
 175 #endif
 176   endService( " SyrComponent_Impl::C_INCR"  );
 177   return ( aCount + 1 ) ;
 178 }
 179
 180 void SyrComponent_Impl::CPP_SETLONG( CORBA::Long aCount ) {
 181   beginService( " SyrComponent_Impl::CPP_SETLONG" );
 182   sendMessage(NOTIF_STEP, "SyrComponent_Impl::CPP_SETLONG is Computing");
 183 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 184   int S = 1 ;
 185 #ifndef WIN32
 186   while ( S ) {
 187     S = sleep( S ) ;
 188   }
 189 #else
 190   Sleep(S*1000);
 191 #endif
 192   _Count = aCount ;
 193   endService( " SyrComponent_Impl::CPP_SETLONG"  );
 194   return ;
 195 }
 196
 197 CORBA::Long SyrComponent_Impl::CPP_ADDTOLONG( CORBA::Long anIncr ) {
 198   beginService( " SyrComponent_Impl::CPP_ADDTOLONG" );
 199   sendMessage(NOTIF_STEP, "SyrComponent_Impl::CPP_ADDTOLONG is Computing");
 200 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 201   int S = 1 ;
 202 #ifndef WIN32
 203   while ( S ) {
 204     S = sleep( S ) ;
 205   }
 206 #else
 207   Sleep(S*1000);
 208 #endif
 209   endService( " SyrComponent_Impl::CPP_ADDTOLONG"  );
 210   return ( _Count + anIncr ) ;
 211 }
 212
 213 CORBA::Long SyrComponent_Impl::C_MIN( CORBA::Long aMinVal , CORBA::Long anInteger ) {
 214   beginService( " SyrComponent_Impl::C_MIN" );
 215   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_MIN is Computing");
 216 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 217   int S = 1 ;
 218 #ifndef WIN32
 219   while ( S ) {
 220     S = sleep( S ) ;
 221   }
 222 #else
 223   Sleep(S*1000);
 224 #endif
 225   int min = aMinVal ;
 226   if ( anInteger < min || aMinVal == 0 ) {
 227     min = anInteger ;
 228   }
 229   string trace = "SyrComponent_Impl::C_MIN : " ;
 230   char cmin[ 30 ] ;
 231   sprintf( cmin , "%d" , min ) ;
 232   trace += cmin ;
 233   sendMessage(NOTIF_TRACE, trace.c_str() );
 234   endService( " SyrComponent_Impl::C_MIN"  );
 235   return min ;
 236 }
 237
 238 CORBA::Long SyrComponent_Impl::C_MAX( CORBA::Long aMaxVal , CORBA::Long anInteger ) {
 239   beginService( " SyrComponent_Impl::C_MAX" );
 240   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_MAX is Computing");
 241 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 242   int S = 1 ;
 243 #ifndef WIN32
 244   while ( S ) {
 245     S = sleep( S ) ;
 246   }
 247 #else
 248   Sleep(S*1000);
 249 #endif
 250   int max = aMaxVal ;
 251   if ( anInteger > max ) {
 252     max = anInteger ;
 253   }
 254   string trace = "SyrComponent_Impl::C_MAX : " ;
 255   char cmax[ 30 ] ;
 256   sprintf( cmax , "%d" , max ) ;
 257   trace += cmax ;
 258   sendMessage(NOTIF_TRACE, trace.c_str() );
 259   endService( " SyrComponent_Impl::C_MAX"  );
 260   return max ;
 261 }
 262
 263 SuperVisionTest::ListOfSyr_ptr SyrComponent_Impl::C_LISTOFSYR() {
 264   beginService( " SyrComponent_Impl::C_LISTOFSYR" );
 265   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_LISTOFSYR is Computing");
 266 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 267   int S = 1 ;
 268 #ifndef WIN32
 269   while ( S ) {
 270     S = sleep( S ) ;
 271   }
 272 #else
 273   Sleep(S*1000);
 274 #endif
 275   ListOfSyr_Impl * aNewListOfSyr = new ListOfSyr_Impl( _orb , _poa, _contId,
 276                         instanceName() , interfaceName() ,
 277                         graphName() , nodeName() ) ;
 278   SuperVisionTest::ListOfSyr_var iobject = (SuperVisionTest::ListOfSyr_var ) NULL ;
 279   PortableServer::ObjectId * id = aNewListOfSyr->getId() ;
 280   CORBA::Object_var obj = _poa->id_to_reference(*id);
 281   iobject = SuperVisionTest::ListOfSyr::_narrow(obj) ;
 282   endService( " SyrComponent_Impl::C_LISTOFSYR"  );
 283   return SuperVisionTest::ListOfSyr::_duplicate( iobject ) ;
 284 //  return ( aNewListOfSyr._retn() ) ;
 285 }
 286
 287 SuperVisionTest::ListOfSyr_ptr SyrComponent_Impl::C_AVERAGE(
 288                        SuperVisionTest::ListOfSyr_ptr aListOfSyr ,
 289                        CORBA::Long anInteger ,
 290                        CORBA::Long aCount ,
 291                        CORBA::Double & anAverage ) {
 292   beginService( " SyrComponent_Impl::C_AVERAGE" );
 293   sendMessage(NOTIF_STEP, "SyrComponent_Impl::C_AVERAGE is Computing");
 294 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 295   int S = 1 ;
 296 #ifndef WIN32
 297   while ( S ) {
 298     S = sleep( S ) ;
 299   }
 300 #else
 301   Sleep(S*1000);
 302 #endif
 303   SuperVisionTest::SeqOfSyr * aSeqOfSyr = aListOfSyr->GetSeqOfSyr() ;
 304   int len = aSeqOfSyr->length() ;
 305   aSeqOfSyr->length( len + 1 ) ;
 306   (*aSeqOfSyr)[ len ] = anInteger ;
 307   aListOfSyr->SetSeqOfSyr( *aSeqOfSyr ) ;
 308   anAverage = 0 ;
 309   int i ;
 310   for ( i = 0 ; i < len + 1 ; i++ ) {
 311     anAverage += (*aSeqOfSyr)[ i ] ;
 312   }
 313   anAverage = anAverage / ( len + 1 ) ;
 314   string end = " SyrComponent_Impl::C_AVERAGE " ;
 315   char caverage[ 30 ] ;
 316   sprintf( caverage , "%fd" , anAverage ) ;
 317   end += caverage ;
 318   endService( end.c_str() );
 319   return SuperVisionTest::ListOfSyr::_duplicate( aListOfSyr ) ;
 320 }
 321
 322 SuperVisionTest::Syr_ptr SyrComponent_Impl::Init( CORBA::Long anOddInteger ) {
 323   beginService( "SyrComponent_Impl::Init" );
 324   sendMessage(NOTIF_STEP, "SyrComponent_Impl creates Syr_Impl");
 325 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 326   int S = 1 ;
 327 #ifndef WIN32
 328   while ( S ) {
 329     S = sleep( S ) ;
 330   }
 331 #else
 332   Sleep(S*1000);
 333 #endif
 334   Syr_Impl * mySyr = nullptr;
 335   if ( this->isSSLMode() )
 336   {
 337     mySyr = new Syr_Impl_SSL( _orb , _poa, _contId,
 338                         instanceName() , interfaceName() ,
 339                         graphName() , nodeName() , anOddInteger ) ;
 340   }
 341   else
 342   {
 343     mySyr = new Syr_Impl_No_SSL( _orb , _poa, _contId,
 344                         instanceName() , interfaceName() ,
 345                         graphName() , nodeName() , anOddInteger ) ;
 346   }
 347   SuperVisionTest::Syr_var iobject = (SuperVisionTest::Syr_var ) NULL ;
 348   PortableServer::ObjectId * id = mySyr->getId() ;
 349   CORBA::Object_var obj = _poa->id_to_reference(*id);
 350   iobject = SuperVisionTest::Syr::_narrow(obj) ;
 351   endService( "SyrComponent_Impl::Init" );
 352   return SuperVisionTest::Syr::_duplicate(iobject) ;
 353 }
 354
 355 ListOfSyr_Impl::ListOfSyr_Impl( CORBA::ORB_ptr orb ,
 356                     PortableServer::POA_ptr poa ,
 357                     PortableServer::ObjectId * contId ,
 358                     const char * instanceName ,
 359                     const char * interfaceName ,
 360                     const char * graphName ,
 361                     const char * nodeName ) :
 362   Engines_Component_i(orb, poa, contId, instanceName, interfaceName,1,true) {
 363   Names( graphName , nodeName ) ;
 364   MESSAGE("ListOfSyr_Impl::ListOfSyr_Impl activate object instanceName("
 365           << instanceName << ") interfaceName(" << interfaceName << ") --> "
 366           << hex << (void *) this << dec )
 367   beginService( "ListOfSyr_Impl::ListOfSyr_Impl" );
 368   _thisObj = this ;
 369   _id = _poa->activate_object(_thisObj);
 370   sendMessage(NOTIF_STEP, "ListOfSyr_Impl is Created");
 371   endService( "ListOfSyr_Impl::ListOfSyr_Impl" );
 372 }
 373
 374 ListOfSyr_Impl::ListOfSyr_Impl() {
 375 }
 376
 377 ListOfSyr_Impl::~ListOfSyr_Impl() {
 378   beginService( "ListOfSyr_Impl::~ListOfSyr_Impl" );
 379   endService( "ListOfSyr_Impl::~ListOfSyr_Impl" );
 380 }
 381
 382 char* ListOfSyr_Impl::getVersion()
 383 {
 384 #if COMPONENT_DEVELOPMENT
 385   return CORBA::string_dup(COMPONENT_VERSION_STR"dev");
 386 #else
 387   return CORBA::string_dup(COMPONENT_VERSION_STR);
 388 #endif
 389 }
 390
 391 SuperVisionTest::SeqOfSyr * ListOfSyr_Impl::GetSeqOfSyr() {
 392   SuperVisionTest::SeqOfSyr_var aSeqOfSyr = new SuperVisionTest::SeqOfSyr( _SeqOfSyr ) ;
 393   return ( aSeqOfSyr._retn() ) ;
 394 }
 395
 396 void ListOfSyr_Impl::SetSeqOfSyr( const SuperVisionTest::SeqOfSyr & aSeqOfSyr ) {
 397   _SeqOfSyr = aSeqOfSyr ;
 398   return ;
 399 }
 400
 401 extern "C"
 402 {
 403   PortableServer::ObjectId * SyrComponentEngine_factory
 404      (CORBA::ORB_ptr orb,
 405       PortableServer::POA_ptr poa,
 406       PortableServer::ObjectId * contId,
 407       const char *instanceName,
 408       const char *interfaceName)
 409   {
 410 #ifndef WIN32
 411     MESSAGE("SyrComponentEngine_factory SyrComponentEngine ("
 412             << instanceName << "," << interfaceName << "," << getpid() << ")");
 413 #else
 414     MESSAGE("SyrComponentEngine_factory SyrComponentEngine ("
 415             << instanceName << "," << interfaceName << "," << _getpid() << ")");
 416 #endif
 417     SyrComponent_Impl * mySyrComponent = nullptr;
 418     CORBA::Object_var o = poa->id_to_reference(*contId);
 419     Engines::Container_var cont = Engines::Container::_narrow(o);
 420     if(cont->is_SSL_mode())
 421     {
 422       mySyrComponent = new SyrComponent_Impl_SSL(orb, poa, contId, instanceName, interfaceName);
 423     }
 424     else
 425     {
 426       mySyrComponent = new SyrComponent_Impl_No_SSL(orb, poa, contId, instanceName, interfaceName);
 427     }
 428     return mySyrComponent->getId() ;
 429   }
 430 }
 431
 432 Syr_Impl::Syr_Impl( CORBA::ORB_ptr orb ,
 433                     PortableServer::POA_ptr poa ,
 434                     PortableServer::ObjectId * contId ,
 435                     const char * instanceName ,
 436                     const char * interfaceName ,
 437                     const char * graphName ,
 438                     const char * nodeName ,
 439                     const CORBA::Long anOddInteger, bool withRegistry) :
 440   SyrComponent_Impl(orb, poa, contId, instanceName, interfaceName,false,withRegistry) {
 441   Names( graphName , nodeName ) ;
 442   MESSAGE("Syr_Impl::Syr_Impl activate object instanceName("
 443           << instanceName << ") interfaceName(" << interfaceName << ") --> "
 444           << hex << (void *) this << dec )
 445   beginService( "Syr_Impl::Syr_Impl" );
 446   _thisObj = this ;
 447   _id = _poa->activate_object(_thisObj);
 448   _InitialInteger = anOddInteger ;
 449   _CurrentInteger = anOddInteger ;
 450   _Count = 0 ;
 451   sendMessage(NOTIF_STEP, "Syr_Impl is Created");
 452   endService( "Syr_Impl::Syr_Impl" );
 453 }
 454
 455 Syr_Impl::Syr_Impl() {
 456 }
 457
 458 Syr_Impl::~Syr_Impl() {
 459   beginService( "Syr_Impl::~Syr_Impl" );
 460   endService( "Syr_Impl::~Syr_Impl" );
 461 }
 462
 463 CORBA::Long Syr_Impl::Initial() {
 464   beginService( " Syr_Impl::Initial" );
 465   sendMessage(NOTIF_STEP, "Syr_Impl::Initial is Computing");
 466 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 467   int S = 1 ;
 468 #ifndef WIN32
 469   while ( S ) {
 470     S = sleep( S ) ;
 471   }
 472 #else
 473   Sleep(S*1000);
 474 #endif
 475   endService( " Syr_Impl::Initial"  );
 476   return _InitialInteger ;
 477 }
 478
 479 CORBA::Long Syr_Impl::Current() {
 480   beginService( " Syr_Impl::Current" );
 481   sendMessage(NOTIF_STEP, "Syr_Impl::Current is Computing");
 482 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 483   int S = 1 ;
 484 #ifndef WIN32
 485   while ( S ) {
 486     S = sleep( S ) ;
 487   }
 488 #else
 489   Sleep(S*1000);
 490 #endif
 491   endService( " Syr_Impl::Current"  );
 492   return _CurrentInteger ;
 493 }
 494
 495 CORBA::Long Syr_Impl::IsEven() {
 496   bool RetVal ;
 497   beginService( " Syr_Impl::IsEven" );
 498   sendMessage(NOTIF_STEP, "Syr_Impl::IsEven is Computing");
 499 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 500   int S = 1 ;
 501 #ifndef WIN32
 502   while ( S ) {
 503     S = sleep( S ) ;
 504   }
 505 #else
 506   Sleep(S*1000);
 507 #endif
 508   RetVal = ( _CurrentInteger & 1 ) == 0 ;
 509   MESSAGE( " Syr_Impl::IsEven " << _CurrentInteger << " " << RetVal );
 510   endService( " Syr_Impl::IsEven"  );
 511   return RetVal ;
 512 }
 513
 514 CORBA::Long Syr_Impl::IsOne() {
 515   bool RetVal ;
 516   beginService( " Syr_Impl::IsOne" );
 517   sendMessage(NOTIF_STEP, "Syr_Impl::IsOne is Computing");
 518 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 519   int S = 1 ;
 520 #ifndef WIN32
 521   while ( S ) {
 522     S = sleep( S ) ;
 523   }
 524 #else
 525   Sleep(S*1000);
 526 #endif
 527   RetVal = ( _CurrentInteger == 1 ) ;
 528   MESSAGE( " Syr_Impl::IsOne " << _CurrentInteger << " " << RetVal );
 529   endService( " Syr_Impl::IsOne"  );
 530   return RetVal ;
 531 }
 532
 533 CORBA::Long Syr_Impl::Count() {
 534   beginService( " Syr_Impl::Count" );
 535   sendMessage(NOTIF_STEP, "Syr_Impl::Count is Computing");
 536 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 537   int S = 1 ;
 538 #ifndef WIN32
 539   while ( S ) {
 540     S = sleep( S ) ;
 541   }
 542 #else
 543   Sleep(S*1000);
 544 #endif
 545   MESSAGE( " Syr_Impl::Count " << _Count );
 546   endService( " Syr_Impl::Count"  );
 547   return _Count ;
 548 }
 549
 550 void Syr_Impl::M3p1() {
 551   beginService( " Syr_Impl::M3p1" );
 552   sendMessage(NOTIF_STEP, "Syr_Impl::M3p1 is Computing");
 553 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 554   int S = 1 ;
 555 #ifndef WIN32
 556   while ( S ) {
 557     S = sleep( S ) ;
 558   }
 559 #else
 560   Sleep(S*1000);
 561 #endif
 562   if ( IsEven() )
 563     _CurrentInteger = 0 ;
 564   else
 565     _CurrentInteger = 3*_CurrentInteger + 1 ;
 566   MESSAGE( " Syr_Impl::M3p1 " << _CurrentInteger );
 567   endService( " Syr_Impl::M3p1"  );
 568 }
 569
 570 void Syr_Impl::Div2() {
 571   beginService( " Syr_Impl::Div2" );
 572   sendMessage(NOTIF_STEP, "Syr_Impl::Div2 is Computing");
 573 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 574   int S = 1 ;
 575 #ifndef WIN32
 576   while ( S ) {
 577     S = sleep( S ) ;
 578   }
 579 #else
 580   Sleep(S*1000);
 581 #endif
 582   if ( !IsEven() )
 583     _CurrentInteger = 0 ;
 584   else
 585     _CurrentInteger = ( _CurrentInteger >> 1 ) ;
 586   MESSAGE( " Syr_Impl::Div2 " << _CurrentInteger );
 587   endService( " Syr_Impl::Div2"  );
 588 }
 589
 590 void Syr_Impl::Incr() {
 591   beginService( " Syr_Impl::Incr" );
 592   sendMessage(NOTIF_STEP, "Syr_Impl::Incr is Computing");
 593 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 594   int S = 1 ;
 595 #ifndef WIN32
 596   while ( S ) {
 597     S = sleep( S ) ;
 598   }
 599 #else
 600   Sleep(S*1000);
 601 #endif
 602   _Count = _Count + 1 ;
 603   MESSAGE( " Syr_Impl::Incr " << _Count );
 604   endService( " Syr_Impl::Incr"  );
 605 }
 606
 607
 608