TAO/tests/Collocation_Opportunities/Collocation_Opportunities.cpp

   1 #include "testS.h"
   2 #include "ace/Task.h"
   3 #include "tao/PortableServer/Object_Adapter.h"
   4 #include "tao/PortableServer/POA_Current.h"
   5 #include "tao/PortableServer/POA_Current_Impl.h"
   6
   7 class test_i :
   8   public POA_test
   9 {
  10 public:
  11
  12   test_i (CORBA::ORB_ptr orb,
  13           PortableServer::POA_ptr poa);
  14
  15   void set_other (test_ptr test);
  16
  17   void method (void);
  18
  19   PortableServer::POA_ptr _default_POA (void);
  20
  21   CORBA::ORB_var orb_;
  22
  23   PortableServer::POA_var poa_;
  24
  25   test_var other_;
  26
  27   PortableServer::Current_var poa_current_;
  28 };
  29
  30 test_i::test_i (CORBA::ORB_ptr orb,
  31                 PortableServer::POA_ptr poa)
  32   : orb_ (CORBA::ORB::_duplicate (orb)),
  33     poa_ (PortableServer::POA::_duplicate (poa))
  34 {
  35   CORBA::Object_var object;
  36
  37   object =
  38     this->orb_->resolve_initial_references ("POACurrent");
  39
  40   this->poa_current_ =
  41     PortableServer::Current::_narrow (object.in ());
  42 }
  43
  44 void
  45 test_i::set_other (test_ptr test)
  46 {
  47   this->other_ = test::_duplicate (test);
  48 }
  49
  50 void
  51 test_i::method (void)
  52 {
  53   if (this->other_.in () != test::_nil ())
  54     {
  55       this->other_->method ();
  56     }
  57   else
  58     {
  59       TAO::Portable_Server::POA_Current &tao_poa_current =
  60         dynamic_cast <TAO::Portable_Server::POA_Current &>
  61                           (*(this->poa_current_.in ()));
  62
  63       TAO::Portable_Server::POA_Current_Impl &tao_poa_current_implementation =
  64         *tao_poa_current.implementation ();
  65
  66       const char *upcall = 0;
  67       if (tao_poa_current_implementation.previous ())
  68         upcall = "collocated";
  69       else
  70         upcall = "remote";
  71
  72       PortableServer::ObjectId_var id =
  73         this->poa_current_->get_object_id ();
  74
  75       CORBA::String_var id_string =
  76         PortableServer::ObjectId_to_string (id.in ());
  77
  78       ACE_DEBUG ((LM_DEBUG,
  79                   "%C method() invoked for <%C> servant in thread %t\n",
  80                   upcall,
  81                   id_string.in ()));
  82     }
  83 }
  84
  85 PortableServer::POA_ptr
  86 test_i::_default_POA (void)
  87 {
  88   return PortableServer::POA::_duplicate (this->poa_.in ());
  89 }
  90
  91 class Task : public ACE_Task_Base
  92 {
  93 public:
  94
  95   Task (CORBA::ORB_ptr orb);
  96
  97   int svc (void);
  98
  99   CORBA::ORB_var orb_;
 100
 101 };
 102
 103 Task::Task (CORBA::ORB_ptr orb)
 104   : orb_ (CORBA::ORB::_duplicate (orb))
 105 {
 106 }
 107
 108 int
 109 Task::svc (void)
 110 {
 111   try
 112     {
 113       this->orb_->run ();
 114     }
 115   catch (const CORBA::Exception&)
 116     {
 117     }
 118
 119   return 0;
 120 }
 121
 122 int
 123 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 124 {
 125   try
 126     {
 127       CORBA::ORB_var orb =
 128         CORBA::ORB_init (argc, argv);
 129
 130       CORBA::Object_var object =
 131         orb->resolve_initial_references ("RootPOA");
 132
 133       PortableServer::POA_var root_poa =
 134         PortableServer::POA::_narrow (object.in ());
 135
 136       PortableServer::POAManager_var poa_manager =
 137         root_poa->the_POAManager ();
 138
 139       poa_manager->activate ();
 140
 141       Task task (orb.in ());
 142
 143       int result =
 144         task.activate ();
 145       ACE_ASSERT (result != -1);
 146       ACE_UNUSED_ARG (result);
 147
 148       CORBA::PolicyList policies (1);
 149       policies.length (1);
 150
 151       policies[0] =
 152         root_poa->create_id_assignment_policy (PortableServer::USER_ID);
 153
 154       PortableServer::POA_var child_poa =
 155         root_poa->create_POA ("child_poa",
 156                               poa_manager.in (),
 157                               policies);
 158
 159       test_i *base_servant =
 160         new test_i (orb.in (),
 161                     child_poa.in ());
 162
 163       PortableServer::ServantBase_var safe_base_servant (base_servant);
 164
 165       PortableServer::ObjectId_var base_oid =
 166         PortableServer::string_to_ObjectId ("base");
 167
 168       child_poa->activate_object_with_id (base_oid.in (),
 169                                           base_servant);
 170
 171       PortableServer::ObjectId_var id_act =
 172         root_poa->activate_object (base_servant);
 173
 174       CORBA::Object_var object_act = root_poa->id_to_reference (id_act.in ());
 175
 176       test_var base_test =
 177         test::_narrow (object_act.in ());
 178
 179       test_i *first_servant =
 180         new test_i (orb.in (),
 181                     child_poa.in ());
 182
 183       PortableServer::ServantBase_var safe_first_servant (first_servant);
 184
 185       PortableServer::ObjectId_var first_oid =
 186         PortableServer::string_to_ObjectId ("first");
 187
 188       child_poa->activate_object_with_id (first_oid.in (),
 189                                           first_servant);
 190
 191       PortableServer::ObjectId_var id_actu =
 192         root_poa->activate_object (first_servant);
 193
 194       object_act = root_poa->id_to_reference (id_actu.in ());
 195
 196       test_var first_test =
 197         test::_narrow (object_act.in ());
 198
 199       base_servant->set_other (first_test.in ());
 200
 201       base_test->method ();
 202
 203       PortableServer::ObjectId_var second_oid =
 204         PortableServer::string_to_ObjectId ("second");
 205
 206       object =
 207         child_poa->create_reference_with_id (second_oid.in (),
 208                                              "IDL:test:1.0");
 209
 210       test_var second_test =
 211         test::_narrow (object.in ());
 212
 213       test_i *second_servant =
 214         new test_i (orb.in (),
 215                     child_poa.in ());
 216
 217       PortableServer::ServantBase_var safe_second_servant (second_servant);
 218
 219       child_poa->activate_object_with_id (second_oid.in (),
 220                                           second_servant);
 221
 222       base_servant->set_other (second_test.in ());
 223
 224       base_test->method ();
 225
 226       PortableServer::ObjectId_var third_oid =
 227         PortableServer::string_to_ObjectId ("third");
 228
 229       object =
 230         child_poa->create_reference_with_id (third_oid.in (),
 231                                              "IDL:test:1.0");
 232
 233       CORBA::String_var third_ior =
 234         orb->object_to_string (object.in ());
 235
 236       object =
 237         orb->string_to_object (third_ior.in ());
 238
 239       test_var third_test =
 240         test::_narrow (object.in ());
 241
 242       test_i *third_servant =
 243         new test_i (orb.in (),
 244                     child_poa.in ());
 245
 246       PortableServer::ServantBase_var safe_third_servant (third_servant);
 247
 248       child_poa->activate_object_with_id (third_oid.in (),
 249                                           third_servant);
 250
 251       base_servant->set_other (third_test.in ());
 252
 253       base_test->method ();
 254
 255       orb->shutdown (1);
 256
 257       result = task.wait ();
 258       ACE_ASSERT (result != -1);
 259       ACE_UNUSED_ARG (result);
 260     }
 261   catch (const CORBA::Exception& ex)
 262     {
 263       ex._tao_print_exception ("Caught exception:");
 264       return -1;
 265     }
 266
 267   return 0;
 268 }