src/AdditionComponent/AdditionComponent_Impl.cxx

   1 // Copyright (C) 2007-2013  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.
  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 AdditionComponent : example of component that adds two numbers
  24 //  File   : AdditionComponent_Impl.cxx
  25 //  Author : Jean Rahuel, CEA
  26 //  Module : SuperVisionTest
  27 //
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <fstream>
  31 #include <sstream>
  32 #include <string>
  33
  34 #include "utilities.h"
  35 #include "Utils_ORB_INIT.hxx"
  36 #include "Utils_SINGLETON.hxx"
  37 #include "SALOME_NamingService.hxx"
  38 #include "SALOME_LifeCycleCORBA.hxx"
  39
  40 #include "AdditionComponent_Impl.hxx"
  41 #include "Adder_Impl.hxx"
  42 #include "COMPONENT_version.h"
  43
  44 using namespace std;
  45
  46 AdditionInterface_Impl::AdditionInterface_Impl( CORBA::ORB_ptr orb,
  47                                       PortableServer::POA_ptr poa,
  48                                       PortableServer::ObjectId * contId,
  49                                       const char *instanceName,
  50                                       const char *interfaceName) :
  51   Engines_Component_i(orb, poa, contId, instanceName, interfaceName,1,true) {
  52   MESSAGE("AdditionInterface_Impl::AdditionInterface_Impl this " << hex << this << dec
  53           << "activate object instanceName("
  54           << instanceName << ") interfaceName(" << interfaceName << ")" )
  55   _thisObj = this ;
  56   _id = _poa->activate_object(_thisObj);
  57   LastAddition = 0 ;
  58 }
  59
  60 AdditionInterface_Impl::AdditionInterface_Impl() {
  61   LastAddition = 0 ;
  62 }
  63
  64 AdditionInterface_Impl::~AdditionInterface_Impl() {
  65 }
  66
  67 char* AdditionInterface_Impl::getVersion()
  68 {
  69 #if COMPONENT_DEVELOPMENT
  70   return CORBA::string_dup(COMPONENT_VERSION_STR"dev");
  71 #else
  72   return CORBA::string_dup(COMPONENT_VERSION_STR);
  73 #endif
  74 }
  75
  76 CORBA::Double AdditionInterface_Impl::Add( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
  77   beginService( " AdditionInterface_Impl::Add" );
  78   z = x + y ;
  79   int S;
  80
  81   sendMessage(NOTIF_STEP, "AdditionInterface_Impl::Add is Computing");
  82 //  S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
  83   S = 5 ;
  84   while ( S ) {
  85     S = sleep(S);
  86   }
  87   MESSAGE( "AdditionInterface_Impl::Add( " <<  x << " , " << y << " , " << z
  88        << " ) returns " << (x - y) << " after " << S << " seconds" )
  89   LastAddition = z ;
  90   endService( " AdditionInterface_Impl::Add"  );
  91   return (x - y) ;
  92 }
  93
  94 CORBA::Double AdditionInterface_Impl::AddWithoutSleep( CORBA::Double x , CORBA::Double y , CORBA::Double & z ) {
  95   beginService( " AdditionInterface_Impl::AddWithoutSleep" );
  96   z = x + y ;
  97   LastAddition = z ;
  98   endService( " AdditionInterface_Impl::AddWithoutSleep" );
  99   return (x - y) ;
 100 }
 101
 102 CORBA::Long AdditionInterface_Impl::Sigma( CORBA::Long n ) {
 103   long sigma = 0 ;
 104   int i , j ;
 105   beginService( " AdditionInterface_Impl::Sigma" );
 106   for ( j = 0 ; j < 1000000 ; j++ ) {
 107     sigma = 0 ;
 108     for ( i = 1 ; i <= n ; i++ ) {
 109       sigma = sigma + i ;
 110     }
 111   }
 112   endService( " AdditionInterface_Impl::Sigma"  );
 113   return sigma ;
 114 }
 115
 116 void AdditionInterface_Impl::Setx( CORBA::Double x ) {
 117   int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
 118   while ( S ) {
 119     S = sleep(S);
 120   }
 121   xx = x ;
 122 }
 123
 124 void AdditionInterface_Impl::Sety( CORBA::Double y ) {
 125   int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
 126   while ( S ) {
 127     S = sleep(S);
 128   }
 129   yy = y ;
 130 }
 131
 132 CORBA::Double AdditionInterface_Impl::Addxy() {
 133   int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
 134   while ( S ) {
 135     S = sleep(S);
 136   }
 137   double zz = xx + yy ;
 138   LastAddition = zz ;
 139   return zz;
 140 }
 141
 142 CORBA::Double AdditionInterface_Impl::AddyTox( CORBA::Double y ) {
 143   int S = 1+(int) (15.0*rand()/(RAND_MAX+1.0));
 144   while ( S ) {
 145     S = sleep(S);
 146   }
 147   double zz = xx + y ;
 148   LastAddition = zz ;
 149   return zz;
 150 }
 151
 152 CORBA::Double AdditionInterface_Impl::LastResult() {
 153   beginService( " AdditionInterface_Impl::LastResult" );
 154   sendMessage(NOTIF_STEP, "AdditionInterface_Impl::LastResult is Computing");
 155   endService( " AdditionInterface_Impl::LastResult"  );
 156   return LastAddition ;
 157 }
 158
 159 AdditionComponent::Adder_ptr AdditionInterface_Impl::Addition() {
 160   beginService( "AdditionInterface_Impl::Addition" );
 161   sendMessage(NOTIF_STEP, "AdditionInterface_Impl creates Adder_Impl");
 162   Adder_Impl * myAdder ;
 163   myAdder = new Adder_Impl( _orb , _poa, _contId,
 164                             instanceName() , interfaceName() ,
 165                             graphName() , nodeName() ) ;
 166   AdditionComponent::Adder_var iobject ;
 167   PortableServer::ObjectId * id = myAdder->getId() ;
 168   CORBA::Object_var obj = _poa->id_to_reference(*id);
 169   iobject = AdditionComponent::Adder::_narrow(obj) ;
 170   endService( "AdditionInterface_Impl::Addition" );
 171   return iobject._retn() ;
 172 //  return AdditionComponent::Adder::_duplicate(iobject) ;
 173 }
 174
 175 bool AdditionInterface_Impl::AdditionObjRef1( AdditionComponent::Adder_out aAdder ) {
 176   beginService( "AdditionInterface_Impl::Addition" );
 177   sendMessage(NOTIF_STEP, "AdditionInterface_Impl creates Adder_Impl");
 178   Adder_Impl * myAdder ;
 179   myAdder = new Adder_Impl( _orb , _poa, _contId,
 180                             instanceName() , interfaceName() ,
 181                             graphName() , nodeName() ) ;
 182   AdditionComponent::Adder_var iobject ;
 183   PortableServer::ObjectId * id = myAdder->getId() ;
 184   CORBA::Object_var obj = _poa->id_to_reference(*id);
 185   iobject = AdditionComponent::Adder::_narrow(obj) ;
 186   endService( "AdditionInterface_Impl::Addition" );
 187   aAdder = AdditionComponent::Adder::_duplicate(iobject) ;
 188   return true ;
 189 }
 190
 191 void AdditionInterface_Impl::AdditionObjRef2( CORBA::Boolean & FuncValue ,
 192                                               AdditionComponent::Adder_out aAdder ) {
 193   beginService( "AdditionInterface_Impl::Addition" );
 194   sendMessage(NOTIF_STEP, "AdditionInterface_Impl creates Adder_Impl");
 195   Adder_Impl * myAdder ;
 196   myAdder = new Adder_Impl( _orb , _poa, _contId,
 197                             instanceName() , interfaceName() ,
 198                             graphName() , nodeName() ) ;
 199   AdditionComponent::Adder_var iobject ;
 200   PortableServer::ObjectId * id = myAdder->getId() ;
 201   CORBA::Object_var obj = _poa->id_to_reference(*id);
 202   iobject = AdditionComponent::Adder::_narrow(obj) ;
 203   endService( "AdditionInterface_Impl::Addition" );
 204   aAdder = AdditionComponent::Adder::_duplicate(iobject) ;
 205   FuncValue = true ;
 206 }
 207
 208 CORBA::Boolean AdditionInterface_Impl::AdditionObjRefs( AdditionComponent::AdditionInterface_ptr AdditionInterface1 ,
 209                                                         AdditionComponent::AdditionInterface_ptr Adder2 ,
 210                                                         AdditionComponent::AdditionInterface_ptr Adder3 ,
 211                                                         AdditionComponent::AdditionInterface_out RetAdditionInterface1 ,
 212                                                         AdditionComponent::AdditionInterface_out RetAdder2 ,
 213                                                         AdditionComponent::AdditionInterface_out RetAdder3 ) {
 214   bool RetVal = true ;
 215   beginService( "AdditionInterface_Impl::AdditionObjRefs" );
 216   cout << "beginService AdditionInterface_Impl::AdditionObjRefs" << endl ;
 217   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 218   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 219   CORBA::ORB_var orb = init(0 , 0 ) ;
 220   char * IOR = orb->object_to_string( AdditionInterface1 );
 221   cout << "AdditionInterface_Impl::AdditionObjRefs AdditionInterface1 " << AdditionInterface1 << " IOR "
 222        << IOR << " nil " << CORBA::is_nil( AdditionInterface1 ) << endl ;
 223   RetAdditionInterface1 = AdditionComponent::AdditionInterface::_duplicate( AdditionInterface1 ) ;
 224   IOR = orb->object_to_string( Adder2 );
 225   cout << "AdditionInterface_Impl::AdditionObjRefs Adder2 " << Adder2 << " IOR " << IOR << " nil "
 226        << CORBA::is_nil( Adder2 ) << endl ;
 227   RetAdder2 = AdditionComponent::AdditionInterface::_duplicate( Adder2 ) ;
 228   IOR = orb->object_to_string( Adder3 );
 229   cout << "AdditionInterface_Impl::AdditionObjRefs Adder3 " << Adder3 << " IOR " << IOR << " nil "
 230        << CORBA::is_nil( Adder3 ) << endl ;
 231   RetAdder3 = AdditionComponent::AdditionInterface::_duplicate( Adder3 ) ;
 232   if ( CORBA::is_nil( AdditionInterface1 ) || CORBA::is_nil( Adder2 ) ||
 233        CORBA::is_nil( Adder3 ) || CORBA::is_nil( RetAdditionInterface1 ) ||
 234        CORBA::is_nil( RetAdder2 ) || CORBA::is_nil( RetAdder3 ) ) {
 235     RetVal = false ;
 236   }
 237   cout << "endService AdditionInterface_Impl::AdditionObjRefs" << endl ;
 238   endService( "AdditionInterface_Impl::AdditionObjRefs" );
 239   return RetVal ;
 240 }
 241
 242 //AdditionComponentEngine_factory
 243 extern "C"
 244 {
 245   PortableServer::ObjectId * AdditionComponentEngine_factory
 246      (CORBA::ORB_ptr orb,
 247       PortableServer::POA_ptr poa,
 248       PortableServer::ObjectId * contId,
 249       const char *instanceName,
 250       const char *interfaceName)
 251   {
 252     MESSAGE("AdditionComponentEngine_factory AdditionInterfaceEngine ("
 253             << instanceName << "," << interfaceName << "," << getpid() << ")");
 254     AdditionInterface_Impl * myAdditionInterface
 255       = new AdditionInterface_Impl(orb, poa, contId, instanceName, interfaceName);
 256     return myAdditionInterface->getId() ;
 257   }
 258 }
 259