TAO/tao/PortableServer/ServantRetentionStrategyNonRetain.cpp

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    ServantRetentionStrategyNonRetain.cpp
   6  */
   7 //=============================================================================
   8
   9 #include "tao/PortableServer/ServantRetentionStrategyNonRetain.h"
  10 #include "tao/PortableServer/Non_Servant_Upcall.h"
  11 #include "tao/PortableServer/Servant_Upcall.h"
  12 #include "tao/PortableServer/POA_Current_Impl.h"
  13 #include "tao/PortableServer/Root_POA.h"
  14 #include "tao/PortableServer/Servant_Base.h"
  15 #include "tao/debug.h"
  16
  17 #include "ace/OS_NS_sys_time.h"
  18 #include "ace/Time_Value.h"
  19 #include "ace/OS_NS_sys_time.h"
  20
  21 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  22
  23 namespace TAO
  24 {
  25   namespace Portable_Server
  26   {
  27     void
  28     ServantRetentionStrategyNonRetain::strategy_init (TAO_Root_POA *poa)
  29     {
  30       poa_ = poa;
  31     }
  32
  33     void
  34     ServantRetentionStrategyNonRetain::strategy_cleanup ()
  35     {
  36       poa_ = nullptr;
  37     }
  38
  39     void
  40     ServantRetentionStrategyNonRetain::deactivate_object (
  41       const PortableServer::ObjectId &/*id*/)
  42     {
  43       // When using Non_Retain we don't have an active object map and we just
  44       // can't deactivate any object
  45       throw PortableServer::POA::WrongPolicy ();
  46     }
  47
  48     PortableServer::Servant
  49     ServantRetentionStrategyNonRetain::find_servant (
  50       const PortableServer::ObjectId &/*system_id*/)
  51     {
  52       throw PortableServer::POA::WrongPolicy ();
  53     }
  54
  55     PortableServer::ObjectId *
  56     ServantRetentionStrategyNonRetain::system_id_to_object_id (
  57       const PortableServer::ObjectId &system_id)
  58     {
  59       // The system id is the id (and no conversion/transformation is
  60       // needed).
  61       PortableServer::ObjectId *id = 0;
  62       ACE_NEW_THROW_EX (id,
  63                         PortableServer::ObjectId (system_id),
  64                         CORBA::NO_MEMORY ());
  65
  66       return id;
  67     }
  68
  69     PortableServer::Servant
  70     ServantRetentionStrategyNonRetain::user_id_to_servant (
  71       const PortableServer::ObjectId &/*id*/)
  72     {
  73       throw PortableServer::POA::WrongPolicy ();
  74     }
  75
  76     CORBA::Object_ptr
  77     ServantRetentionStrategyNonRetain::id_to_reference (
  78       const PortableServer::ObjectId &/*id*/,
  79       bool /*indirect*/)
  80     {
  81       throw PortableServer::POA::WrongPolicy ();
  82     }
  83
  84     TAO_Servant_Location
  85     ServantRetentionStrategyNonRetain::servant_present (
  86       const PortableServer::ObjectId &/*system_id*/,
  87       PortableServer::Servant &/*servant*/)
  88     {
  89       return TAO_Servant_Location::Not_Found;
  90     }
  91
  92     PortableServer::Servant
  93     ServantRetentionStrategyNonRetain::find_servant (
  94       const PortableServer::ObjectId &system_id,
  95       TAO::Portable_Server::Servant_Upcall &servant_upcall,
  96       TAO::Portable_Server::POA_Current_Impl &poa_current_impl)
  97     {
  98       // We have the NON_RETAIN policy, user id is the system id.
  99
 100       // Smartly copy all the data; <poa_current_impl.object_id_> does
 101       // not own the data.
 102       poa_current_impl.replace_object_id (system_id);
 103
 104       servant_upcall.user_id (&system_id);
 105
 106       return 0;
 107     }
 108
 109     int
 110     ServantRetentionStrategyNonRetain::find_servant_priority (
 111         const PortableServer::ObjectId &/*system_id*/,
 112         CORBA::Short &/*priority*/)
 113     {
 114       return -1;
 115     }
 116
 117     int
 118     ServantRetentionStrategyNonRetain::is_servant_in_map (
 119       PortableServer::Servant /*servant*/,
 120       bool &/*wait_occurred_restart_call*/)
 121     {
 122       return 0;
 123     }
 124
 125     CORBA::ULong
 126     ServantRetentionStrategyNonRetain::waiting_servant_deactivation () const
 127     {
 128       return 0;
 129     }
 130
 131     void
 132     ServantRetentionStrategyNonRetain::deactivate_all_objects ()
 133     {
 134     }
 135
 136     PortableServer::ObjectId *
 137     ServantRetentionStrategyNonRetain::servant_to_user_id (
 138       PortableServer::Servant /*servant*/)
 139     {
 140       throw PortableServer::POA::WrongPolicy ();
 141     }
 142
 143     CORBA::Object_ptr
 144     ServantRetentionStrategyNonRetain::servant_to_reference (
 145       PortableServer::Servant /*servant*/)
 146     {
 147       throw PortableServer::POA::WrongPolicy ();
 148     }
 149
 150     PortableServer::ObjectId *
 151     ServantRetentionStrategyNonRetain::activate_object (
 152       PortableServer::Servant /*servant*/,
 153       CORBA::Short /*priority*/,
 154       bool &/*wait_occurred_restart_call*/)
 155     {
 156       throw PortableServer::POA::WrongPolicy ();
 157     }
 158
 159     void
 160     ServantRetentionStrategyNonRetain::activate_object_with_id (
 161       const PortableServer::ObjectId &/*id*/,
 162       PortableServer::Servant /*servant*/,
 163       CORBA::Short /*priority*/,
 164       bool &/*wait_occurred_restart_call*/)
 165     {
 166       throw PortableServer::POA::WrongPolicy ();
 167     }
 168
 169     CORBA::Object_ptr
 170     ServantRetentionStrategyNonRetain::create_reference (
 171       const char *intf,
 172       CORBA::Short priority)
 173     {
 174       // This operation creates an object reference that encapsulates a
 175       // POA-generated Object Id value and the specified interface
 176       // repository id. This operation does not cause an activation to
 177       // take place. The resulting reference may be passed to clients, so
 178       // that subsequent requests on those references will cause the
 179       // appropriate servant manager to be invoked, if one is
 180       // available. The generated Object Id value may be obtained by
 181       // invoking POA::reference_to_id with the created reference.
 182
 183       PortableServer::ObjectId_var system_id;
 184       PortableServer::ObjectId user_id;
 185
 186       // Otherwise, it is the NON_RETAIN policy.  Therefore, any ol'
 187       // object id will do (even an empty one). However, to make an
 188       // object id useful for discriminating objects in applications
 189       // use a simple id of a counter and a time stamp. The use of a
 190       // counter by itself is not sufficient for uniqueness over time
 191       // and a timestamp isn't sufficient since multiple IDs may be
 192       // requested within the same time unit.
 193
 194       PortableServer::ObjectId *sys_id = 0;
 195       ACE_NEW_THROW_EX (sys_id,
 196                         PortableServer::ObjectId (8),
 197                         CORBA::NO_MEMORY ());
 198
 199       sys_id->length(8);
 200
 201       long count = this->sys_id_count_++;
 202       ACE_Time_Value now = ACE_OS::gettimeofday();
 203
 204       ACE_UINT32 *id_ptr = reinterpret_cast<ACE_UINT32 *>(sys_id->get_buffer());
 205
 206       *(id_ptr++) = count;
 207       *id_ptr = static_cast<ACE_UINT32>(now.sec());
 208
 209       system_id = sys_id;
 210
 211       // User id is the same as system id.
 212       user_id = system_id.in ();
 213
 214       // Remember params for potentially invoking <key_to_object> later.
 215       this->poa_->key_to_object_params_.set (system_id,
 216                                              intf,
 217                                              0,
 218                                              1,
 219                                              priority,
 220                                              true);
 221
 222       return this->poa_->invoke_key_to_object_helper_i (intf, user_id);
 223     }
 224
 225 #if !defined (CORBA_E_MICRO)
 226     CORBA::Object_ptr
 227     ServantRetentionStrategyNonRetain::create_reference_with_id (
 228       const PortableServer::ObjectId &oid,
 229       const char *intf,
 230       CORBA::Short priority)
 231     {
 232       // This operation creates an object reference that encapsulates the
 233       // specified Object Id and interface repository Id values. This
 234       // operation does not cause an activation to take place.  The
 235       // resulting reference may be passed to clients, so that subsequent
 236       // requests on those references will cause the object to be
 237       // activated if necessary, or the default servant used, depending on
 238       // the applicable policies.
 239
 240       PortableServer::Servant servant = 0;
 241       PortableServer::ObjectId_var system_id;
 242
 243       // Otherwise, it is the NON_RETAIN policy.  Therefore, user id
 244       // is the same as system id.
 245       PortableServer::ObjectId *sys_id = 0;
 246       ACE_NEW_THROW_EX (sys_id,
 247                         PortableServer::ObjectId (oid),
 248                         CORBA::NO_MEMORY ());
 249
 250       system_id = sys_id;
 251
 252       // Remember params for potentially invoking <key_to_object> later.
 253       this->poa_->key_to_object_params_.set (system_id,
 254                                              intf,
 255                                              servant,
 256                                              1,
 257                                              priority,
 258                                              true);
 259
 260       return this->poa_->invoke_key_to_object_helper_i (intf, oid);
 261     }
 262 #endif
 263
 264     int
 265     ServantRetentionStrategyNonRetain::rebind_using_user_id_and_system_id (
 266       PortableServer::Servant /*servant*/,
 267       const PortableServer::ObjectId &/*user_id*/,
 268       const PortableServer::ObjectId &/*system_id*/,
 269       TAO::Portable_Server::Servant_Upcall &/*servant_upcall*/)
 270     {
 271       return -1;
 272     }
 273
 274     CORBA::Boolean
 275     ServantRetentionStrategyNonRetain::servant_has_remaining_activations (
 276       PortableServer::Servant /*servant*/)
 277     {
 278       return false;
 279     }
 280
 281     int
 282     ServantRetentionStrategyNonRetain::unbind_using_user_id (
 283       const PortableServer::ObjectId &/*user_id*/)
 284     {
 285       return 0;
 286     }
 287
 288     ::PortableServer::ServantRetentionPolicyValue
 289     ServantRetentionStrategyNonRetain::type() const
 290     {
 291       return ::PortableServer::NON_RETAIN;
 292     }
 293
 294     TAO_Active_Object_Map *
 295     ServantRetentionStrategyNonRetain::get_active_object_map() const
 296     {
 297       return 0;
 298     }
 299   }
 300 }
 301
 302 TAO_END_VERSIONED_NAMESPACE_DECL
 303