Root_POA.h
Go to the documentation of this file.
00001 // -*- C++ -*- 00002 00003 //============================================================================= 00004 /** 00005 * @file Root_POA.h 00006 * 00007 * $Id: Root_POA.h 90434 2010-06-06 18:17:15Z johnnyw $ 00008 * 00009 * Header file for CORBA's ORB type. 00010 * 00011 * @author Irfan Pyarali <irfan@cs.wustl.edu> 00012 */ 00013 //============================================================================= 00014 00015 #ifndef TAO_ROOT_POA_H 00016 #define TAO_ROOT_POA_H 00017 00018 #include /**/ "ace/pre.h" 00019 00020 #include "tao/PortableServer/portableserver_export.h" 00021 00022 #if !defined (ACE_LACKS_PRAGMA_ONCE) 00023 # pragma once 00024 #endif /* ACE_LACKS_PRAGMA_ONCE */ 00025 00026 // Object Adapter 00027 #include "tao/PortableServer/Object_Adapter.h" 00028 00029 // POA Policy Set 00030 #include "tao/PortableServer/POA_Policy_Set.h" 00031 00032 // Cached POA Policies 00033 #include "tao/PortableServer/POA_Cached_Policies.h" 00034 #include "tao/PortableServer/Active_Policy_Strategies.h" 00035 00036 #include "tao/PortableServer/ORT_Adapter.h" 00037 00038 #include "tao/PortableServer/PortableServer.h" 00039 00040 // Object_Key 00041 #include "tao/Object_KeyC.h" 00042 00043 // Local Object 00044 #include "tao/LocalObject.h" 00045 00046 // Portable Interceptor 00047 #include "tao/PI_ForwardC.h" 00048 00049 // OctetSeq 00050 #include "tao/OctetSeqC.h" 00051 00052 #include "ace/SString.h" 00053 #include "ace/Hash_Map_Manager_T.h" 00054 #include "ace/Array_Base.h" 00055 #include "ace/Synch_Traits.h" 00056 #include "ace/Thread_Mutex.h" 00057 #include "ace/Recursive_Thread_Mutex.h" 00058 #include "ace/Null_Mutex.h" 00059 00060 // This is to remove "inherits via dominance" warnings from MSVC. 00061 // MSVC is being a little too paranoid. 00062 #if defined(_MSC_VER) 00063 #pragma warning(push) 00064 #pragma warning(disable:4250) 00065 #endif /* _MSC_VER */ 00066 00067 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00068 00069 // Forward Declaration 00070 class TAO_Acceptor_Filter; 00071 00072 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00073 class TAO_Acceptor_Filter_Factory; 00074 class TAO_POAManager_Factory; 00075 #endif 00076 00077 class TAO_Network_Priority_Hook; 00078 class TAO_Acceptor_Registry; 00079 class TAO_IORInfo; 00080 class TAO_Regular_POA; 00081 00082 namespace PortableInterceptor 00083 { 00084 class IORInfo; 00085 typedef IORInfo *IORInfo_ptr; 00086 } 00087 00088 namespace TAO 00089 { 00090 class ORT_Adapter; 00091 class ORT_Adapter_Factory; 00092 00093 namespace Portable_Server 00094 { 00095 class Servant_Upcall; 00096 class POA_Current_Impl; 00097 class Temporary_Creation_Time; 00098 } 00099 } 00100 00101 namespace PortableServer 00102 { 00103 class POAManager; 00104 typedef POAManager *POAManager_ptr; 00105 } 00106 00107 /** 00108 * @class TAO_Root_POA 00109 * 00110 * @brief Implementation of the PortableServer::POA interface. 00111 * 00112 * Implementation of the PortableServer::POA interface. 00113 */ 00114 class TAO_PortableServer_Export TAO_Root_POA 00115 : public virtual PortableServer::POA, 00116 public virtual ::CORBA::LocalObject 00117 { 00118 public: 00119 00120 friend class TAO_Object_Adapter; 00121 friend class TAO::Portable_Server::Servant_Upcall; 00122 friend class TAO::Portable_Server::Non_Servant_Upcall; 00123 friend class TAO_POA_Manager; 00124 friend class TAO_RT_Collocation_Resolver; 00125 friend class TAO_IORInfo; 00126 00127 typedef ACE_CString String; 00128 00129 #if !defined (CORBA_E_MICRO) 00130 PortableServer::POA_ptr create_POA ( 00131 const char *adapter_name, 00132 PortableServer::POAManager_ptr poa_manager, 00133 const CORBA::PolicyList &policies); 00134 00135 PortableServer::POA_ptr find_POA (const char *adapter_name, 00136 CORBA::Boolean activate_it); 00137 #endif 00138 00139 void destroy (CORBA::Boolean etherealize_objects, 00140 CORBA::Boolean wait_for_completion); 00141 00142 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00143 PortableServer::ThreadPolicy_ptr create_thread_policy ( 00144 PortableServer::ThreadPolicyValue value); 00145 #endif /* TAO_HAS_MINIMUM_POA == 0 */ 00146 00147 #if !defined (CORBA_E_MICRO) 00148 PortableServer::LifespanPolicy_ptr create_lifespan_policy ( 00149 PortableServer::LifespanPolicyValue value); 00150 #endif 00151 00152 #if !defined (CORBA_E_MICRO) 00153 PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy ( 00154 PortableServer::IdUniquenessPolicyValue value); 00155 #endif 00156 00157 #if !defined (CORBA_E_MICRO) 00158 PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy ( 00159 PortableServer::IdAssignmentPolicyValue value); 00160 #endif 00161 00162 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00163 PortableServer::ImplicitActivationPolicy_ptr 00164 create_implicit_activation_policy ( 00165 PortableServer::ImplicitActivationPolicyValue value); 00166 00167 PortableServer::ServantRetentionPolicy_ptr 00168 create_servant_retention_policy ( 00169 PortableServer::ServantRetentionPolicyValue value); 00170 00171 PortableServer::RequestProcessingPolicy_ptr 00172 create_request_processing_policy ( 00173 PortableServer::RequestProcessingPolicyValue value); 00174 00175 #endif /* TAO_HAS_MINIMUM_POA == 0 && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) */ 00176 00177 char * the_name (void); 00178 00179 PortableServer::POA_ptr the_parent (void); 00180 00181 PortableServer::POAList *the_children (void); 00182 00183 PortableServer::POAManager_ptr the_POAManager (void); 00184 00185 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00186 PortableServer::POAManagerFactory_ptr the_POAManagerFactory (void); 00187 #endif 00188 00189 /// This method returns the adapter_name as a sequence of strings of 00190 /// length one or more or just a fixed name depending on the Object 00191 /// Adapter. Added wrt to ORT Spec. 00192 PortableInterceptor::AdapterName *adapter_name (void); 00193 00194 /// Store the given TaggedComponent for eventual insertion into all 00195 /// object reference profiles. 00196 void save_ior_component (const IOP::TaggedComponent &component); 00197 00198 /// Store the given TaggedComponent for eventual insertion into all 00199 /// object reference profiles with the given ProfileId. 00200 void save_ior_component_and_profile_id ( 00201 const IOP::TaggedComponent &component, 00202 IOP::ProfileId profile_id); 00203 00204 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00205 PortableServer::AdapterActivator_ptr the_activator (void); 00206 00207 void the_activator (PortableServer::AdapterActivator_ptr adapter_activator); 00208 00209 PortableServer::ServantManager_ptr get_servant_manager (void); 00210 00211 void set_servant_manager (PortableServer::ServantManager_ptr imgr); 00212 00213 PortableServer::Servant get_servant (void); 00214 00215 void set_servant (PortableServer::Servant servant); 00216 #endif /* TAO_HAS_MINIMUM_POA == 0 !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) */ 00217 00218 PortableServer::ObjectId *activate_object (PortableServer::Servant p_servant); 00219 00220 void activate_object_with_id (const PortableServer::ObjectId &id, 00221 PortableServer::Servant p_servant); 00222 00223 void deactivate_object (const PortableServer::ObjectId &oid); 00224 00225 CORBA::Object_ptr create_reference (const char *intf); 00226 00227 #if !defined (CORBA_E_MICRO) 00228 CORBA::Object_ptr create_reference_with_id ( 00229 const PortableServer::ObjectId &oid, 00230 const char *intf); 00231 #endif 00232 00233 PortableServer::ObjectId *servant_to_id (PortableServer::Servant p_servant); 00234 00235 PortableServer::ObjectId *servant_to_user_id (PortableServer::Servant p_servant); 00236 00237 CORBA::Object_ptr servant_to_reference (PortableServer::Servant p_servant); 00238 00239 PortableServer::Servant reference_to_servant (CORBA::Object_ptr reference); 00240 00241 PortableServer::ObjectId *reference_to_id (CORBA::Object_ptr reference); 00242 00243 PortableServer::Servant id_to_servant (const PortableServer::ObjectId &oid); 00244 00245 CORBA::Object_ptr id_to_reference (const PortableServer::ObjectId &oid); 00246 00247 CORBA::OctetSeq *id (void); 00248 00249 /// Accessor for POA policies. 00250 TAO_POA_Policy_Set &policies (void); 00251 00252 /// Get the set policy of the given type. 00253 CORBA::Policy_ptr get_policy (CORBA::PolicyType policy); 00254 00255 /// This method gives the policies that are exposed to the client. 00256 /// These policies are shipped within the IOR. 00257 virtual CORBA::PolicyList *client_exposed_policies ( 00258 CORBA::Short object_priority); 00259 00260 TAO_Root_POA (const String &name, 00261 PortableServer::POAManager_ptr poa_manager, 00262 const TAO_POA_Policy_Set &policies, 00263 TAO_Root_POA *parent, 00264 ACE_Lock &lock, 00265 TAO_SYNCH_MUTEX &thread_lock, 00266 TAO_ORB_Core &orb_core, 00267 TAO_Object_Adapter *object_adapter); 00268 00269 virtual ~TAO_Root_POA (void); 00270 00271 static char name_separator (void); 00272 00273 static CORBA::ULong name_separator_length (void); 00274 00275 enum 00276 { 00277 TAO_OBJECTKEY_PREFIX_SIZE = 4 00278 }; 00279 00280 static CORBA::Octet const objectkey_prefix[TAO_OBJECTKEY_PREFIX_SIZE]; 00281 00282 const TAO_Object_Adapter::poa_name &folded_name (void) const; 00283 00284 const TAO_Object_Adapter::poa_name &system_name (void) const; 00285 00286 static void check_for_valid_wait_for_completions ( 00287 const TAO_ORB_Core &orb_core, 00288 CORBA::Boolean wait_for_completion); 00289 00290 /// ORB Core for POA. 00291 TAO_ORB_Core &orb_core (void) const; 00292 00293 /// obtain a reference to the cached_profiles 00294 TAO::Portable_Server::Cached_Policies& cached_policies (void); 00295 00296 /// obtain a handle to the network priority hooks 00297 TAO_Network_Priority_Hook* network_priority_hook (void); 00298 00299 TAO::Portable_Server::Cached_Policies::PriorityModel priority_model (void) const; 00300 00301 CORBA::Boolean cleanup_in_progress (void); 00302 00303 /// Calls protected static method used when POACurrent is not appropriate. 00304 static int parse_ir_object_key (const TAO::ObjectKey &object_key, 00305 PortableServer::ObjectId &user_id); 00306 00307 TAO_Object_Adapter &object_adapter (void); 00308 00309 ACE_Lock &lock (void); 00310 00311 /// Create the correct stub, properly initialized with the 00312 /// attributes and policies attached to the current POA. 00313 TAO_Stub* key_to_stub (const TAO::ObjectKey &key, 00314 const char *type_id, 00315 CORBA::Short priority); 00316 00317 /// Accessor methods to POA state. 00318 /** 00319 * The POA can be in one of HOLDING, ACTIVE, DISCARDING, INACTIVE 00320 * and NON_EXISTENT states. 00321 */ 00322 PortableInterceptor::AdapterState get_adapter_state (void); 00323 00324 virtual void *thread_pool (void) const; 00325 00326 virtual CORBA::Policy *server_protocol (void); 00327 00328 CORBA::ULong outstanding_requests (void) const; 00329 00330 const ACE_CString &name (void) const; 00331 00332 CORBA::Boolean waiting_destruction (void) const; 00333 00334 static void ort_adapter_factory_name (const char *name); 00335 00336 static const char *ort_adapter_factory_name (void); 00337 00338 /// Sets the value of TAO_POA_Static_Resources::imr_client_adapter_name_. 00339 static void imr_client_adapter_name (const char *name); 00340 00341 /// Gets the value of TAO_POA_Static_Resources::imr_client_adapter_name_. 00342 static const char *imr_client_adapter_name (void); 00343 00344 CORBA::Object_ptr invoke_key_to_object (void); 00345 00346 CORBA::Boolean system_id (void); 00347 00348 CORBA::ULong waiting_servant_deactivation (void) const; 00349 00350 /// Return the POA Manager related to this POA 00351 TAO_POA_Manager &tao_poa_manager (); 00352 00353 bool is_poa_generated (CORBA::Object_ptr reference, 00354 PortableServer::ObjectId &system_id); 00355 00356 /* 00357 * Validate if the servant may be activated 00358 * @retval true This servant may be activated 00359 * @retval false This servant may not be activated 00360 */ 00361 bool is_servant_activation_allowed ( 00362 PortableServer::Servant servant, 00363 bool &wait_occurred_restart_call); 00364 00365 int rebind_using_user_id_and_system_id ( 00366 PortableServer::Servant servant, 00367 const PortableServer::ObjectId &user_id, 00368 const PortableServer::ObjectId &system_id, 00369 TAO::Portable_Server::Servant_Upcall &servant_upcall); 00370 00371 CORBA::Boolean servant_has_remaining_activations ( 00372 PortableServer::Servant servant); 00373 00374 bool allow_implicit_activation (void) const; 00375 00376 bool allow_multiple_activations (void) const; 00377 00378 int is_servant_active ( 00379 PortableServer::Servant servant, 00380 bool &wait_occurred_restart_call); 00381 00382 void deactivate_object_i (const PortableServer::ObjectId &oid); 00383 00384 CORBA::Boolean is_persistent (void) const; 00385 00386 CORBA::Short server_priority (void) const; 00387 00388 bool has_system_id (void) const; 00389 00390 PortableServer::Servant find_servant (const PortableServer::ObjectId &system_id); 00391 00392 TAO_SERVANT_LOCATION servant_present ( 00393 const PortableServer::ObjectId &system_id, 00394 PortableServer::Servant &servant); 00395 00396 PortableServer::Servant find_servant ( 00397 const PortableServer::ObjectId &system_id, 00398 TAO::Portable_Server::Servant_Upcall &servant_upcall, 00399 TAO::Portable_Server::POA_Current_Impl &poa_current_impl); 00400 00401 /** 00402 * Find the the servant with ObjectId <system_id>, and retrieve 00403 * its priority. Usually used in RT CORBA with SERVER_DECLARED 00404 * priority model. 00405 * 00406 * @return -1 if servant does not exist, else 0 indicating the 00407 * servant exists and priority successfully retrieved. 00408 */ 00409 int find_servant_priority ( 00410 const PortableServer::ObjectId &system_id, 00411 CORBA::Short &priority); 00412 00413 int unbind_using_user_id (const PortableServer::ObjectId &user_id); 00414 00415 void cleanup_servant ( 00416 PortableServer::Servant servant, 00417 const PortableServer::ObjectId &user_id); 00418 00419 void post_invoke_servant_cleanup( 00420 const PortableServer::ObjectId &system_id, 00421 const TAO::Portable_Server::Servant_Upcall &servant_upcall); 00422 00423 bool validate_lifespan ( 00424 CORBA::Boolean is_persistent, 00425 const TAO::Portable_Server::Temporary_Creation_Time& creation_time) const; 00426 00427 PortableServer::ObjectId *activate_object_i ( 00428 PortableServer::Servant p_servant, 00429 CORBA::Short priority, 00430 bool &wait_occurred_restart_call); 00431 00432 CORBA::Object_ptr id_to_reference_i (const PortableServer::ObjectId &oid, 00433 bool indirect); 00434 00435 PortableServer::ObjectId *servant_to_id_i (PortableServer::Servant servant); 00436 00437 TAO_SYNCH_CONDITION &servant_deactivation_condition (void); 00438 00439 int is_poa_generated_id (const PortableServer::ObjectId &id); 00440 00441 /// Check the state of this POA 00442 void check_state (void); 00443 00444 int delete_child (const String &child); 00445 00446 PortableServer::Servant user_id_to_servant_i (const PortableServer::ObjectId &oid); 00447 00448 virtual CORBA::ORB_ptr _get_orb (void); 00449 00450 /// These hooks are needed by the CSD strategy to override 00451 /// and no-ops by default. 00452 00453 /// Hook - The POA has been (or is being) activated. 00454 virtual void poa_activated_hook (); 00455 00456 /// Hook - The POA has been deactivated. 00457 virtual void poa_deactivated_hook (); 00458 00459 /// Hook - A servant has been activated. 00460 virtual void servant_activated_hook (PortableServer::Servant servant, 00461 const PortableServer::ObjectId& oid); 00462 00463 /// Hook - A servant has been deactivated. 00464 virtual void servant_deactivated_hook (PortableServer::Servant servant, 00465 const PortableServer::ObjectId& oid); 00466 00467 protected: 00468 00469 #if (TAO_HAS_MINIMUM_POA == 0) 00470 int enter (void); 00471 00472 int exit (void); 00473 #endif /* TAO_HAS_MINIMUM_POA == 0 */ 00474 00475 #if ! defined (CORBA_E_MICRO) 00476 /// Template method for creating new POA's of this type. 00477 virtual TAO_Root_POA *new_POA (const String &name, 00478 PortableServer::POAManager_ptr poa_manager, 00479 const TAO_POA_Policy_Set &policies, 00480 TAO_Root_POA *parent, 00481 ACE_Lock &lock, 00482 TAO_SYNCH_MUTEX &thread_lock, 00483 TAO_ORB_Core &orb_core, 00484 TAO_Object_Adapter *object_adapter); 00485 00486 PortableServer::POA_ptr create_POA_i ( 00487 const char *adapter_name, 00488 PortableServer::POAManager_ptr poa_manager, 00489 const CORBA::PolicyList &policies); 00490 00491 PortableServer::POA_ptr create_POA_i (const String &adapter_name, 00492 PortableServer::POAManager_ptr poa_manager, 00493 const TAO_POA_Policy_Set &policies); 00494 00495 TAO_Root_POA *find_POA_i (const ACE_CString &child_name, 00496 CORBA::Boolean activate_it); 00497 #endif 00498 00499 void destroy_i (CORBA::Boolean etherealize_objects, 00500 CORBA::Boolean wait_for_completion); 00501 00502 void complete_destruction_i (void); 00503 00504 PortableServer::POAList *the_children_i (void); 00505 00506 /// This method returns the adapter_name as a sequence of strings of 00507 /// length one or more or just a fixed name depending on the Object 00508 /// Adapter. Added wrt to ORT Spec. 00509 PortableInterceptor::AdapterName *adapter_name_i (void); 00510 00511 /// Method to notify the IOR Interceptors when there is a state 00512 /// changed not related to POAManager. 00513 void adapter_state_changed ( 00514 const TAO::ORT_Array &array_obj_ref_template, 00515 PortableInterceptor::AdapterState state); 00516 00517 /// Add the given tagged component to all profiles. 00518 void add_ior_component (TAO_MProfile & mprofile, 00519 const IOP::TaggedComponent & component); 00520 00521 /// Add the given tagged component to all profiles matching the given 00522 /// ProfileId. 00523 void add_ior_component_to_profile (TAO_MProfile & mprofile, 00524 const IOP::TaggedComponent & component, 00525 IOP::ProfileId profile_id); 00526 00527 /// Wrapper for the ORB's key_to_object that will alter the object pointer 00528 /// if the ImplRepo is used. 00529 CORBA::Object_ptr key_to_object (const TAO::ObjectKey &key, 00530 const char *type_id, 00531 TAO_ServantBase *servant, 00532 CORBA::Boolean collocated, 00533 CORBA::Short priority, 00534 bool indirect); 00535 00536 /// Like key_to_stub() but assume that the ORB is not shutting down. 00537 virtual TAO_Stub* key_to_stub_i (const TAO::ObjectKey &key, 00538 const char *type_id, 00539 CORBA::Short priority); 00540 00541 TAO_Stub *create_stub_object (const TAO::ObjectKey &object_key, 00542 const char *type_id, 00543 CORBA::PolicyList *policy_list, 00544 TAO_Acceptor_Filter *filter, 00545 TAO_Acceptor_Registry &acceptor_registry); 00546 00547 PortableServer::Servant get_servant_i (void); 00548 00549 protected: 00550 void activate_object_with_id_i (const PortableServer::ObjectId &id, 00551 PortableServer::Servant p_servant, 00552 CORBA::Short priority, 00553 bool &wait_occurred_restart_call); 00554 00555 virtual void remove_from_parent_i (void); 00556 00557 void deactivate_all_objects_i (CORBA::Boolean etherealize_objects); 00558 00559 void deactivate_all_objects_i (CORBA::Boolean etherealize_objects, 00560 CORBA::Boolean wait_for_completion); 00561 00562 void wait_for_completions (CORBA::Boolean wait_for_completion); 00563 00564 CORBA::Object_ptr create_reference_i (const char *intf, 00565 CORBA::Short priority); 00566 00567 CORBA::Object_ptr create_reference_with_id_i ( 00568 const PortableServer::ObjectId &oid, 00569 const char *intf, 00570 CORBA::Short priority); 00571 00572 PortableServer::Servant reference_to_servant_i (CORBA::Object_ptr reference); 00573 00574 CORBA::Object_ptr servant_to_reference_i (PortableServer::Servant p_servant); 00575 00576 PortableServer::Servant id_to_servant_i (const PortableServer::ObjectId &oid); 00577 00578 /// Call the IORInterceptor::establish_components() method on all 00579 /// registered IORInterceptors. 00580 /** 00581 * This method calls IORInterceptor::establish_components() method 00582 * on all registered IORInterceptors, and 00583 * IORInterceptor::components_established() once the former is 00584 * completed. 00585 */ 00586 void establish_components (void); 00587 00588 /// Call the IORInterceptor::components_established() method on all 00589 /// registered IORInterceptors. 00590 void components_established (PortableInterceptor::IORInfo_ptr info); 00591 00592 void set_folded_name (TAO_Root_POA *parent); 00593 00594 void set_id (TAO_Root_POA *parent); 00595 00596 TAO::ObjectKey *create_object_key (const PortableServer::ObjectId &id); 00597 00598 static int parse_key (const TAO::ObjectKey &key, 00599 TAO_Object_Adapter::poa_name &poa_system_name, 00600 PortableServer::ObjectId &system_id, 00601 CORBA::Boolean &is_root, 00602 CORBA::Boolean &is_persistent, 00603 CORBA::Boolean &is_system_id, 00604 TAO::Portable_Server::Temporary_Creation_Time &poa_creation_time); 00605 00606 protected: 00607 /// Accessor methods to ObjectReferenceTemplate 00608 PortableInterceptor::ObjectReferenceTemplate * 00609 get_adapter_template (void); 00610 00611 /// Accessor methods to ObjectReferenceTemplate, non locked version 00612 PortableInterceptor::ObjectReferenceTemplate *get_adapter_template_i (void); 00613 00614 /// Accessor methods to PortableInterceptor::ObjectReferenceFactory 00615 PortableInterceptor::ObjectReferenceFactory *get_obj_ref_factory (void); 00616 00617 /// Set the object reference factory 00618 void set_obj_ref_factory ( 00619 PortableInterceptor::ObjectReferenceFactory *current_factory); 00620 00621 00622 TAO_SERVANT_LOCATION locate_servant_i (const PortableServer::ObjectId &id, 00623 PortableServer::Servant &servant); 00624 00625 PortableServer::Servant locate_servant_i ( 00626 const char *operation, 00627 const PortableServer::ObjectId &id, 00628 TAO::Portable_Server::Servant_Upcall &servant_upcall, 00629 TAO::Portable_Server::POA_Current_Impl &poa_current_impl, 00630 bool &wait_occurred_restart_call); 00631 00632 public: 00633 /// @todo Temporarily for servant retention 00634 CORBA::Object_ptr 00635 invoke_key_to_object_helper_i (const char * repository_id, 00636 const PortableServer::ObjectId & id); 00637 protected: 00638 00639 /// Get the ORT adapter, in case there is no adapter yet, this method will 00640 /// try to create one and hold the POA lock 00641 TAO::ORT_Adapter *ORT_adapter (void); 00642 00643 /// Get the ORT adapter, in case there is no adapter yet, this method will 00644 /// try to create one but assumes the POA lock is already hold 00645 TAO::ORT_Adapter *ORT_adapter_i (void); 00646 00647 TAO::ORT_Adapter_Factory *ORT_adapter_factory (void); 00648 00649 CORBA::Boolean persistent (void); 00650 00651 static char persistent_key_char (void); 00652 00653 static char transient_key_char (void); 00654 00655 static CORBA::ULong persistent_key_type_length (void); 00656 00657 static char system_id_key_char (void); 00658 00659 static char user_id_key_char (void); 00660 00661 static CORBA::ULong system_id_key_type_length (void); 00662 00663 virtual CORBA::Boolean root (void) const; 00664 00665 virtual char root_key_type (void); 00666 00667 static char root_key_char (void); 00668 00669 static char non_root_key_char (void); 00670 00671 static CORBA::ULong root_key_type_length (void); 00672 00673 void outstanding_requests (CORBA::ULong new_outstanding_requests); 00674 00675 CORBA::ULong increment_outstanding_requests (void); 00676 00677 CORBA::ULong decrement_outstanding_requests (void); 00678 00679 String name_; 00680 00681 /// Reference to the POAManager that this poa assicuates with. 00682 TAO_POA_Manager &poa_manager_; 00683 00684 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00685 /// Reference to the POAManagerFactory that generate the POAManager. 00686 TAO_POAManager_Factory& poa_manager_factory_; 00687 #endif 00688 00689 IOP::TaggedComponentSeq tagged_component_; 00690 00691 IOP::TaggedComponentSeq tagged_component_id_; 00692 00693 ACE_Array_Base <IOP::ProfileId> profile_id_array_; 00694 00695 TAO_POA_Policy_Set policies_; 00696 00697 TAO_Object_Adapter::poa_name folded_name_; 00698 00699 TAO_Object_Adapter::poa_name_var system_name_; 00700 00701 CORBA::OctetSeq id_; 00702 00703 /// Pointer to the object reference template adapter. 00704 TAO::ORT_Adapter *ort_adapter_; 00705 00706 /// Adapter can be accepting, rejecting etc. 00707 PortableInterceptor::AdapterState adapter_state_; 00708 00709 TAO::Portable_Server::Cached_Policies cached_policies_; 00710 00711 TAO_Network_Priority_Hook *network_priority_hook_; 00712 00713 TAO::Portable_Server::Active_Policy_Strategies active_policy_strategies_; 00714 00715 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00716 PortableServer::AdapterActivator_var adapter_activator_; 00717 #endif /* TAO_HAS_MINIMUM_POA == 0 !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) */ 00718 00719 typedef 00720 ACE_Hash_Map_Manager_Ex< 00721 ACE_CString, TAO_Root_POA *, 00722 ACE_Hash<ACE_CString>, 00723 ACE_Equal_To<ACE_CString>, 00724 ACE_Null_Mutex 00725 > 00726 CHILDREN; 00727 00728 CHILDREN children_; 00729 00730 ACE_Lock &lock_; 00731 00732 TAO_ORB_Core &orb_core_; 00733 00734 /// The object adapter we belong to 00735 TAO_Object_Adapter *object_adapter_; 00736 00737 CORBA::Boolean cleanup_in_progress_; 00738 00739 CORBA::ULong outstanding_requests_; 00740 00741 TAO_SYNCH_CONDITION outstanding_requests_condition_; 00742 00743 CORBA::Boolean wait_for_completion_pending_; 00744 00745 CORBA::Boolean waiting_destruction_; 00746 00747 TAO_SYNCH_CONDITION servant_deactivation_condition_; 00748 00749 #if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO) 00750 TAO_Acceptor_Filter_Factory * filter_factory_; 00751 #endif 00752 00753 public: 00754 // @todo Temporarily for servant retention 00755 CORBA::ULong caller_key_to_object_; 00756 00757 PortableServer::Servant servant_for_key_to_object_; 00758 00759 struct Key_To_Object_Params 00760 { 00761 PortableServer::ObjectId_var *system_id_; 00762 const char *type_id_; 00763 TAO_ServantBase *servant_; 00764 CORBA::Boolean collocated_; 00765 CORBA::Short priority_; 00766 bool indirect_; 00767 00768 void set (PortableServer::ObjectId_var &system_id_, 00769 const char *type_id_, 00770 TAO_ServantBase *servant_, 00771 CORBA::Boolean collocated_, 00772 CORBA::Short priority_, 00773 bool indirect); 00774 }; 00775 00776 Key_To_Object_Params key_to_object_params_; 00777 }; 00778 00779 /** 00780 * @class TAO_POA_Static_Resources 00781 * 00782 * @brief The static (global) resoures of all POA's. 00783 * 00784 * This class is used by the POA to store the resources global to 00785 * all POA's. All instance variables that would have been 00786 * declared "static" in TAO_Regular_POA, should be declared in this class 00787 * to avoid the "static initialization order fiasco" as described in 00788 * http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.11. 00789 * Briefly, this is the problem that occurs if any static initializers 00790 * in any other code call into set static members of TAO_Regular_POA. 00791 * Since the order in which these initializers execute is unspecified, 00792 * uninitialized members can be accessed. 00793 */ 00794 class TAO_PortableServer_Export TAO_POA_Static_Resources 00795 { 00796 public: 00797 00798 /// Return the singleton instance. 00799 static TAO_POA_Static_Resources* instance (void); 00800 00801 /// Cleanup the static singleton 00802 static void fini (void) ACE_GCC_DESTRUCTOR_ATTRIBUTE; 00803 00804 public: 00805 00806 /** 00807 * Name of the factory object used to adapt function calls on the 00808 * PortableInterceptor interfaces ORT. The default value is 00809 * "ObjectReferenceTemplate_Adapter_Factory". If the ORT library is linked, 00810 * the corresponding accessor function 00811 * objectreferencefactory_adapter_factory_name() will be called to set 00812 * the value to "Concrete_ObjectReferenceTemplate_Adapter_Factory". 00813 */ 00814 ACE_CString ort_adapter_factory_name_; 00815 00816 /** 00817 * Name of the service object for functions that make calls on 00818 * the Implementation Repository. The default value is "ImR_Client_Adapter". 00819 * If TAO_IMR_CLient is linked, imr_client_adapter_name() will be 00820 * called to set the value to "Concrete_ImR_Client_Adapter". 00821 */ 00822 ACE_CString imr_client_adapter_name_; 00823 private: 00824 /// Constructor. 00825 TAO_POA_Static_Resources (void); 00826 00827 private: 00828 /// The singleton instance. 00829 static TAO_POA_Static_Resources* instance_; 00830 00831 /// Mostly unused variable whose sole purpose is to enforce 00832 /// the instantiation of a TAO_POA_Static_Resources instance 00833 /// at initialization time. 00834 static TAO_POA_Static_Resources* initialization_reference_; 00835 }; 00836 00837 TAO_END_VERSIONED_NAMESPACE_DECL 00838 00839 // **************************************************************** 00840 00841 #if defined(_MSC_VER) 00842 #pragma warning(pop) 00843 #endif /* _MSC_VER */ 00844 00845 #if defined (__ACE_INLINE__) 00846 # include "tao/PortableServer/Root_POA.inl" 00847 #endif /* __ACE_INLINE__ */ 00848 00849 #include /**/ "ace/post.h" 00850 00851 #endif /* TAO_ROOT_POA_H */
