TAO/tao/PortableServer/Active_Policy_Strategies.cpp

   1 // -*- C++ -*-
   2 #include "tao/PortableServer/Active_Policy_Strategies.h"
   3 #include "tao/PortableServer/POA_Cached_Policies.h"
   4
   5 #include "tao/PortableServer/ThreadStrategySingle.h"
   6 #include "tao/PortableServer/ThreadStrategyORBControl.h"
   7 #include "tao/PortableServer/IdAssignmentStrategySystem.h"
   8 #include "tao/PortableServer/IdAssignmentStrategyUser.h"
   9 #include "tao/PortableServer/IdUniquenessStrategyMultiple.h"
  10 #include "tao/PortableServer/IdUniquenessStrategyUnique.h"
  11 #include "tao/PortableServer/ImplicitActivationStrategyExplicit.h"
  12 #include "tao/PortableServer/ImplicitActivationStrategyImplicit.h"
  13 #include "tao/PortableServer/LifespanStrategyPersistent.h"
  14 #include "tao/PortableServer/LifespanStrategyTransient.h"
  15 #include "tao/PortableServer/RequestProcessingStrategyAOMOnly.h"
  16 #include "tao/PortableServer/RequestProcessingStrategyDefaultServant.h"
  17 #include "tao/PortableServer/RequestProcessingStrategyServantLocator.h"
  18 #include "tao/PortableServer/RequestProcessingStrategyServantActivator.h"
  19 #include "tao/PortableServer/ServantRetentionStrategyNonRetain.h"
  20 #include "tao/PortableServer/ServantRetentionStrategyRetain.h"
  21
  22 #if !defined (__ACE_INLINE__)
  23 # include "tao/PortableServer/Active_Policy_Strategies.inl"
  24 #endif /* __ACE_INLINE__ */
  25
  26 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  27
  28 namespace TAO
  29 {
  30   namespace Portable_Server
  31   {
  32     void
  33     Active_Policy_Strategies::update (Cached_Policies &policies,
  34                                       ::TAO_Root_POA *poa)
  35     {
  36       this->create (policies.thread());
  37       this->create (policies.id_assignment());
  38       this->create (policies.id_uniqueness());
  39       this->create (policies.servant_retention());
  40       this->create (policies.lifespan());
  41       this->create (policies.implicit_activation());
  42       this->create (policies.request_processing(), policies.servant_retention());
  43
  44       /**/
  45       if (this->lifespan_strategy_)
  46         {
  47           this->lifespan_strategy_->strategy_init (poa);
  48         }
  49
  50       if (this->request_processing_strategy_)
  51         {
  52           this->request_processing_strategy_->strategy_init (poa);
  53         }
  54
  55       if (this->id_uniqueness_strategy_)
  56         {
  57           this->id_uniqueness_strategy_->strategy_init (poa);
  58         }
  59
  60       if (this->servant_retention_strategy_)
  61         {
  62           this->servant_retention_strategy_->strategy_init (poa);
  63         }
  64     }
  65
  66     void
  67     Active_Policy_Strategies::cleanup ()
  68     {
  69       if (this->lifespan_strategy_)
  70         {
  71           this->lifespan_strategy_->strategy_cleanup ();
  72         }
  73       this->lifespan_strategy_.reset (nullptr);
  74       if (this->request_processing_strategy_)
  75         {
  76           this->request_processing_strategy_->strategy_cleanup ();
  77         }
  78       this->request_processing_strategy_.reset (nullptr);
  79       if (this->id_uniqueness_strategy_)
  80         {
  81           this->id_uniqueness_strategy_->strategy_cleanup ();
  82         }
  83       this->id_uniqueness_strategy_.reset (nullptr);
  84       this->implicit_activation_strategy_.reset (nullptr);
  85       this->thread_strategy_.reset (nullptr);
  86       if (this->servant_retention_strategy_)
  87         {
  88           this->servant_retention_strategy_->strategy_cleanup ();
  89         }
  90       this->servant_retention_strategy_.reset (nullptr);
  91       this->id_assignment_strategy_.reset (nullptr);
  92     }
  93
  94     void
  95     Active_Policy_Strategies::create (::PortableServer::ThreadPolicyValue value)
  96     {
  97       switch (value)
  98       {
  99         case ::PortableServer::SINGLE_THREAD_MODEL :
 100         {
 101 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_MICRO) && !defined (CORBA_E_COMPACT)
 102           this->thread_strategy_ = std::make_unique<ThreadStrategySingle> ();
 103 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 104           break;
 105         }
 106         case ::PortableServer::ORB_CTRL_MODEL :
 107         {
 108           this->thread_strategy_ = std::make_unique<ThreadStrategyORBControl> ();
 109           break;
 110         }
 111       }
 112     }
 113
 114     void
 115     Active_Policy_Strategies::create (::PortableServer::IdAssignmentPolicyValue value)
 116     {
 117       switch (value)
 118       {
 119         case ::PortableServer::SYSTEM_ID :
 120         {
 121           this->id_assignment_strategy_ = std::make_unique<IdAssignmentStrategySystem> ();
 122           break;
 123         }
 124         case ::PortableServer::USER_ID :
 125         {
 126 #if !defined (CORBA_E_MICRO)
 127           this->id_assignment_strategy_ = std::make_unique<IdAssignmentStrategyUser> ();
 128 #endif /* CORBA_E_MICRO */
 129           break;
 130         }
 131       }
 132     }
 133
 134     void
 135     Active_Policy_Strategies::create (::PortableServer::IdUniquenessPolicyValue value)
 136     {
 137       switch (value)
 138       {
 139         case ::PortableServer::MULTIPLE_ID :
 140         {
 141 #if !defined (CORBA_E_MICRO)
 142           this->id_uniqueness_strategy_ = std::make_unique<IdUniquenessStrategyMultiple> ();
 143 #endif /* CORBA_E_MICRO */
 144           break;
 145         }
 146         case ::PortableServer::UNIQUE_ID :
 147         {
 148           this->id_uniqueness_strategy_ = std::make_unique<IdUniquenessStrategyUnique> ();
 149           break;
 150         }
 151       }
 152     }
 153
 154     void
 155     Active_Policy_Strategies::create (::PortableServer::ServantRetentionPolicyValue value)
 156     {
 157       switch (value)
 158       {
 159         case ::PortableServer::RETAIN :
 160         {
 161           this->servant_retention_strategy_ = std::make_unique<ServantRetentionStrategyRetain> ();
 162           break;
 163         }
 164         case ::PortableServer::NON_RETAIN :
 165         {
 166 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_MICRO) && !defined (CORBA_E_COMPACT)
 167           this->servant_retention_strategy_ = std::make_unique<ServantRetentionStrategyNonRetain> ();
 168 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 169           break;
 170         }
 171       }
 172     }
 173
 174     void
 175     Active_Policy_Strategies::create (::PortableServer::LifespanPolicyValue value)
 176     {
 177       switch (value)
 178       {
 179         case ::PortableServer::PERSISTENT :
 180         {
 181 #if !defined (CORBA_E_MICRO)
 182           this->lifespan_strategy_ = std::make_unique<LifespanStrategyPersistent> ();
 183 #endif /* CORBA_E_MICRO */
 184           break;
 185         }
 186         case ::PortableServer::TRANSIENT :
 187         {
 188           this->lifespan_strategy_ = std::make_unique<LifespanStrategyTransient> ();
 189           break;
 190         }
 191       }
 192     }
 193
 194     void
 195     Active_Policy_Strategies::create (::PortableServer::ImplicitActivationPolicyValue value)
 196     {
 197       switch (value)
 198       {
 199         case ::PortableServer::IMPLICIT_ACTIVATION :
 200         {
 201 #if !defined (CORBA_E_MICRO) && !defined (CORBA_E_COMPACT)
 202           this->implicit_activation_strategy_= std::make_unique<ImplicitActivationStrategyImplicit> ();
 203 #endif /* CORBA_E_MICRO */
 204           break;
 205         }
 206         case ::PortableServer::NO_IMPLICIT_ACTIVATION :
 207         {
 208           this->implicit_activation_strategy_ = std::make_unique<ImplicitActivationStrategyExplicit> ();
 209           break;
 210         }
 211       }
 212     }
 213
 214     void
 215     Active_Policy_Strategies::create (
 216         ::PortableServer::RequestProcessingPolicyValue value,
 217         ::PortableServer::ServantRetentionPolicyValue srvalue)
 218     {
 219       switch (value)
 220       {
 221         case ::PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY :
 222         {
 223           this->request_processing_strategy_ = std::make_unique<RequestProcessingStrategyAOMOnly> ();
 224           break;
 225         }
 226         case ::PortableServer::USE_DEFAULT_SERVANT :
 227         {
 228 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
 229           this->request_processing_strategy_ = std::make_unique<RequestProcessingStrategyDefaultServant> ();
 230 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 231           break;
 232         }
 233         case ::PortableServer::USE_SERVANT_MANAGER :
 234         {
 235           switch (srvalue)
 236           {
 237             case ::PortableServer::RETAIN :
 238             {
 239 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
 240               this->request_processing_strategy_ = std::make_unique<RequestProcessingStrategyServantActivator> ();
 241 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 242               break;
 243             }
 244             case ::PortableServer::NON_RETAIN :
 245             {
 246 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
 247               this->request_processing_strategy_ = std::make_unique<RequestProcessingStrategyServantLocator> ();
 248 #endif /* TAO_HAS_MINIMUM_POA == 0 */
 249               break;
 250             }
 251           }
 252           break;
 253         }
 254       }
 255     }
 256   }
 257 }
 258
 259 TAO_END_VERSIONED_NAMESPACE_DECL