src/SyrComponent/SyrComponent_Impl.cxx

   1 // Copyright (C) 2007-2021  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 ) :
  50   Engines_Component_i(orb, poa, contId, instanceName, interfaceName,1,true) {
  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 ;
 335   mySyr = new Syr_Impl( _orb , _poa, _contId,
 336                         instanceName() , interfaceName() ,
 337                         graphName() , nodeName() , anOddInteger ) ;
 338   SuperVisionTest::Syr_var iobject = (SuperVisionTest::Syr_var ) NULL ;
 339   PortableServer::ObjectId * id = mySyr->getId() ;
 340   CORBA::Object_var obj = _poa->id_to_reference(*id);
 341   iobject = SuperVisionTest::Syr::_narrow(obj) ;
 342   endService( "SyrComponent_Impl::Init" );
 343   return SuperVisionTest::Syr::_duplicate(iobject) ;
 344 }
 345
 346 ListOfSyr_Impl::ListOfSyr_Impl( CORBA::ORB_ptr orb ,
 347                     PortableServer::POA_ptr poa ,
 348                     PortableServer::ObjectId * contId ,
 349                     const char * instanceName ,
 350                     const char * interfaceName ,
 351                     const char * graphName ,
 352                     const char * nodeName ) :
 353   Engines_Component_i(orb, poa, contId, instanceName, interfaceName,1,true) {
 354   Names( graphName , nodeName ) ;
 355   MESSAGE("ListOfSyr_Impl::ListOfSyr_Impl activate object instanceName("
 356           << instanceName << ") interfaceName(" << interfaceName << ") --> "
 357           << hex << (void *) this << dec )
 358   beginService( "ListOfSyr_Impl::ListOfSyr_Impl" );
 359   _thisObj = this ;
 360   _id = _poa->activate_object(_thisObj);
 361   sendMessage(NOTIF_STEP, "ListOfSyr_Impl is Created");
 362   endService( "ListOfSyr_Impl::ListOfSyr_Impl" );
 363 }
 364
 365 ListOfSyr_Impl::ListOfSyr_Impl() {
 366 }
 367
 368 ListOfSyr_Impl::~ListOfSyr_Impl() {
 369   beginService( "ListOfSyr_Impl::~ListOfSyr_Impl" );
 370   endService( "ListOfSyr_Impl::~ListOfSyr_Impl" );
 371 }
 372
 373 char* ListOfSyr_Impl::getVersion()
 374 {
 375 #if COMPONENT_DEVELOPMENT
 376   return CORBA::string_dup(COMPONENT_VERSION_STR"dev");
 377 #else
 378   return CORBA::string_dup(COMPONENT_VERSION_STR);
 379 #endif
 380 }
 381
 382 SuperVisionTest::SeqOfSyr * ListOfSyr_Impl::GetSeqOfSyr() {
 383   SuperVisionTest::SeqOfSyr_var aSeqOfSyr = new SuperVisionTest::SeqOfSyr( _SeqOfSyr ) ;
 384   return ( aSeqOfSyr._retn() ) ;
 385 }
 386
 387 void ListOfSyr_Impl::SetSeqOfSyr( const SuperVisionTest::SeqOfSyr & aSeqOfSyr ) {
 388   _SeqOfSyr = aSeqOfSyr ;
 389   return ;
 390 }
 391
 392 extern "C"
 393 {
 394   PortableServer::ObjectId * SyrComponentEngine_factory
 395      (CORBA::ORB_ptr orb,
 396       PortableServer::POA_ptr poa,
 397       PortableServer::ObjectId * contId,
 398       const char *instanceName,
 399       const char *interfaceName)
 400   {
 401 #ifndef WIN32
 402     MESSAGE("SyrComponentEngine_factory SyrComponentEngine ("
 403             << instanceName << "," << interfaceName << "," << getpid() << ")");
 404 #else
 405     MESSAGE("SyrComponentEngine_factory SyrComponentEngine ("
 406             << instanceName << "," << interfaceName << "," << _getpid() << ")");
 407 #endif
 408     SyrComponent_Impl * mySyrComponent
 409       = new SyrComponent_Impl(orb, poa, contId, instanceName, interfaceName);
 410     return mySyrComponent->getId() ;
 411   }
 412 }
 413
 414 Syr_Impl::Syr_Impl( CORBA::ORB_ptr orb ,
 415                     PortableServer::POA_ptr poa ,
 416                     PortableServer::ObjectId * contId ,
 417                     const char * instanceName ,
 418                     const char * interfaceName ,
 419                     const char * graphName ,
 420                     const char * nodeName ,
 421                     const CORBA::Long anOddInteger ) :
 422   SyrComponent_Impl(orb, poa, contId, instanceName, interfaceName,false) {
 423   Names( graphName , nodeName ) ;
 424   MESSAGE("Syr_Impl::Syr_Impl activate object instanceName("
 425           << instanceName << ") interfaceName(" << interfaceName << ") --> "
 426           << hex << (void *) this << dec )
 427   beginService( "Syr_Impl::Syr_Impl" );
 428   _thisObj = this ;
 429   _id = _poa->activate_object(_thisObj);
 430   _InitialInteger = anOddInteger ;
 431   _CurrentInteger = anOddInteger ;
 432   _Count = 0 ;
 433   sendMessage(NOTIF_STEP, "Syr_Impl is Created");
 434   endService( "Syr_Impl::Syr_Impl" );
 435 }
 436
 437 Syr_Impl::Syr_Impl() {
 438 }
 439
 440 Syr_Impl::~Syr_Impl() {
 441   beginService( "Syr_Impl::~Syr_Impl" );
 442   endService( "Syr_Impl::~Syr_Impl" );
 443 }
 444
 445 CORBA::Long Syr_Impl::Initial() {
 446   beginService( " Syr_Impl::Initial" );
 447   sendMessage(NOTIF_STEP, "Syr_Impl::Initial is Computing");
 448 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 449   int S = 1 ;
 450 #ifndef WIN32
 451   while ( S ) {
 452     S = sleep( S ) ;
 453   }
 454 #else
 455   Sleep(S*1000);
 456 #endif
 457   endService( " Syr_Impl::Initial"  );
 458   return _InitialInteger ;
 459 }
 460
 461 CORBA::Long Syr_Impl::Current() {
 462   beginService( " Syr_Impl::Current" );
 463   sendMessage(NOTIF_STEP, "Syr_Impl::Current is Computing");
 464 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 465   int S = 1 ;
 466 #ifndef WIN32
 467   while ( S ) {
 468     S = sleep( S ) ;
 469   }
 470 #else
 471   Sleep(S*1000);
 472 #endif
 473   endService( " Syr_Impl::Current"  );
 474   return _CurrentInteger ;
 475 }
 476
 477 CORBA::Long Syr_Impl::IsEven() {
 478   bool RetVal ;
 479   beginService( " Syr_Impl::IsEven" );
 480   sendMessage(NOTIF_STEP, "Syr_Impl::IsEven is Computing");
 481 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 482   int S = 1 ;
 483 #ifndef WIN32
 484   while ( S ) {
 485     S = sleep( S ) ;
 486   }
 487 #else
 488   Sleep(S*1000);
 489 #endif
 490   RetVal = ( _CurrentInteger & 1 ) == 0 ;
 491   MESSAGE( " Syr_Impl::IsEven " << _CurrentInteger << " " << RetVal );
 492   endService( " Syr_Impl::IsEven"  );
 493   return RetVal ;
 494 }
 495
 496 CORBA::Long Syr_Impl::IsOne() {
 497   bool RetVal ;
 498   beginService( " Syr_Impl::IsOne" );
 499   sendMessage(NOTIF_STEP, "Syr_Impl::IsOne is Computing");
 500 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 501   int S = 1 ;
 502 #ifndef WIN32
 503   while ( S ) {
 504     S = sleep( S ) ;
 505   }
 506 #else
 507   Sleep(S*1000);
 508 #endif
 509   RetVal = ( _CurrentInteger == 1 ) ;
 510   MESSAGE( " Syr_Impl::IsOne " << _CurrentInteger << " " << RetVal );
 511   endService( " Syr_Impl::IsOne"  );
 512   return RetVal ;
 513 }
 514
 515 CORBA::Long Syr_Impl::Count() {
 516   beginService( " Syr_Impl::Count" );
 517   sendMessage(NOTIF_STEP, "Syr_Impl::Count 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   MESSAGE( " Syr_Impl::Count " << _Count );
 528   endService( " Syr_Impl::Count"  );
 529   return _Count ;
 530 }
 531
 532 void Syr_Impl::M3p1() {
 533   beginService( " Syr_Impl::M3p1" );
 534   sendMessage(NOTIF_STEP, "Syr_Impl::M3p1 is Computing");
 535 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 536   int S = 1 ;
 537 #ifndef WIN32
 538   while ( S ) {
 539     S = sleep( S ) ;
 540   }
 541 #else
 542   Sleep(S*1000);
 543 #endif
 544   if ( IsEven() )
 545     _CurrentInteger = 0 ;
 546   else
 547     _CurrentInteger = 3*_CurrentInteger + 1 ;
 548   MESSAGE( " Syr_Impl::M3p1 " << _CurrentInteger );
 549   endService( " Syr_Impl::M3p1"  );
 550 }
 551
 552 void Syr_Impl::Div2() {
 553   beginService( " Syr_Impl::Div2" );
 554   sendMessage(NOTIF_STEP, "Syr_Impl::Div2 is Computing");
 555 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 556   int S = 1 ;
 557 #ifndef WIN32
 558   while ( S ) {
 559     S = sleep( S ) ;
 560   }
 561 #else
 562   Sleep(S*1000);
 563 #endif
 564   if ( !IsEven() )
 565     _CurrentInteger = 0 ;
 566   else
 567     _CurrentInteger = ( _CurrentInteger >> 1 ) ;
 568   MESSAGE( " Syr_Impl::Div2 " << _CurrentInteger );
 569   endService( " Syr_Impl::Div2"  );
 570 }
 571
 572 void Syr_Impl::Incr() {
 573   beginService( " Syr_Impl::Incr" );
 574   sendMessage(NOTIF_STEP, "Syr_Impl::Incr is Computing");
 575 //  int S = 1+(int) (2.0*rand()/(RAND_MAX+1.0));
 576   int S = 1 ;
 577 #ifndef WIN32
 578   while ( S ) {
 579     S = sleep( S ) ;
 580   }
 581 #else
 582   Sleep(S*1000);
 583 #endif
 584   _Count = _Count + 1 ;
 585   MESSAGE( " Syr_Impl::Incr " << _Count );
 586   endService( " Syr_Impl::Incr"  );
 587 }
 588
 589
 590