TAO_Root_POA Class Reference

Implementation of the PortableServer::POA interface. More...

#include <Root_POA.h>

Inheritance diagram for TAO_Root_POA:

[legend]Collaboration diagram for TAO_Root_POA:

[legend]List of all members.

Public Types
typedef ACE_CString	String
	TAO_OBJECTKEY_PREFIX_SIZE = 4
enum	{ TAO_OBJECTKEY_PREFIX_SIZE = 4 }
Public Member Functions
PortableServer::POA_ptr	create_POA (const char *adapter_name, PortableServer::POAManager_ptr poa_manager, const CORBA::PolicyList &policies)
PortableServer::POA_ptr	find_POA (const char *adapter_name, CORBA::Boolean activate_it)
void	destroy (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion)
PortableServer::ThreadPolicy_ptr	create_thread_policy (PortableServer::ThreadPolicyValue value)
PortableServer::LifespanPolicy_ptr	create_lifespan_policy (PortableServer::LifespanPolicyValue value)
PortableServer::IdUniquenessPolicy_ptr	create_id_uniqueness_policy (PortableServer::IdUniquenessPolicyValue value)
PortableServer::IdAssignmentPolicy_ptr	create_id_assignment_policy (PortableServer::IdAssignmentPolicyValue value)
PortableServer::ImplicitActivationPolicy_ptr	create_implicit_activation_policy (PortableServer::ImplicitActivationPolicyValue value)
PortableServer::ServantRetentionPolicy_ptr	create_servant_retention_policy (PortableServer::ServantRetentionPolicyValue value)
PortableServer::RequestProcessingPolicy_ptr	create_request_processing_policy (PortableServer::RequestProcessingPolicyValue value)
char *	the_name (void)
PortableServer::POA_ptr	the_parent (void)
PortableServer::POAList *	the_children (void)
PortableServer::POAManager_ptr	the_POAManager (void)
PortableServer::POAManagerFactory_ptr	the_POAManagerFactory (void)
PortableInterceptor::AdapterName *	adapter_name (void)
void	save_ior_component (const IOP::TaggedComponent &component)
void	save_ior_component_and_profile_id (const IOP::TaggedComponent &component, IOP::ProfileId profile_id)
PortableServer::AdapterActivator_ptr	the_activator (void)
void	the_activator (PortableServer::AdapterActivator_ptr adapter_activator)
PortableServer::ServantManager_ptr	get_servant_manager (void)
void	set_servant_manager (PortableServer::ServantManager_ptr imgr)
PortableServer::Servant	get_servant (void)
void	set_servant (PortableServer::Servant servant)
PortableServer::ObjectId *	activate_object (PortableServer::Servant p_servant)
void	activate_object_with_id (const PortableServer::ObjectId &id, PortableServer::Servant p_servant)
void	deactivate_object (const PortableServer::ObjectId &oid)
CORBA::Object_ptr	create_reference (const char *intf)
CORBA::Object_ptr	create_reference_with_id (const PortableServer::ObjectId &oid, const char *intf)
PortableServer::ObjectId *	servant_to_id (PortableServer::Servant p_servant)
PortableServer::ObjectId *	servant_to_user_id (PortableServer::Servant p_servant)
CORBA::Object_ptr	servant_to_reference (PortableServer::Servant p_servant)
PortableServer::Servant	reference_to_servant (CORBA::Object_ptr reference)
PortableServer::ObjectId *	reference_to_id (CORBA::Object_ptr reference)
PortableServer::Servant	id_to_servant (const PortableServer::ObjectId &oid)
CORBA::Object_ptr	id_to_reference (const PortableServer::ObjectId &oid)
CORBA::OctetSeq *	id (void)
TAO_POA_Policy_Set &	policies (void)
	Accessor for POA policies.
CORBA::Policy_ptr	get_policy (CORBA::PolicyType policy)
	Get the set policy of the given type.
virtual CORBA::PolicyList *	client_exposed_policies (CORBA::Short object_priority)
	TAO_Root_POA (const String &name, PortableServer::POAManager_ptr poa_manager, const TAO_POA_Policy_Set &policies, TAO_Root_POA *parent, ACE_Lock &lock, TAO_SYNCH_MUTEX &thread_lock, TAO_ORB_Core &orb_core, TAO_Object_Adapter *object_adapter)
virtual	~TAO_Root_POA (void)
const TAO_Object_Adapter::poa_name &	folded_name (void) const
const TAO_Object_Adapter::poa_name &	system_name (void) const
TAO_ORB_Core &	orb_core (void) const
	ORB Core for POA.
TAO::Portable_Server::Cached_Policies &	cached_policies (void)
	obtain a reference to the cached_profiles
TAO_Network_Priority_Hook *	network_priority_hook (void)
	obtain a handle to the network priority hooks
TAO::Portable_Server::Cached_Policies::PriorityModel	priority_model (void) const
CORBA::Boolean	cleanup_in_progress (void)
TAO_Object_Adapter &	object_adapter (void)
ACE_Lock &	lock (void)
TAO_Stub *	key_to_stub (const TAO::ObjectKey &key, const char *type_id, CORBA::Short priority)
PortableInterceptor::AdapterState	get_adapter_state (void)
	Accessor methods to POA state.
virtual void *	thread_pool (void) const
virtual CORBA::Policy *	server_protocol (void)
CORBA::ULong	outstanding_requests (void) const
const ACE_CString &	name (void) const
CORBA::Boolean	waiting_destruction (void) const
CORBA::Object_ptr	invoke_key_to_object (void)
CORBA::Boolean	system_id (void)
CORBA::ULong	waiting_servant_deactivation (void) const
TAO_POA_Manager &	tao_poa_manager ()
	Return the POA Manager related to this POA.
bool	is_poa_generated (CORBA::Object_ptr reference, PortableServer::ObjectId &system_id)
bool	is_servant_activation_allowed (PortableServer::Servant servant, bool &wait_occurred_restart_call)
int	rebind_using_user_id_and_system_id (PortableServer::Servant servant, const PortableServer::ObjectId &user_id, const PortableServer::ObjectId &system_id, TAO::Portable_Server::Servant_Upcall &servant_upcall)
CORBA::Boolean	servant_has_remaining_activations (PortableServer::Servant servant)
bool	allow_implicit_activation (void) const
bool	allow_multiple_activations (void) const
int	is_servant_active (PortableServer::Servant servant, bool &wait_occurred_restart_call)
void	deactivate_object_i (const PortableServer::ObjectId &oid)
CORBA::Boolean	is_persistent (void) const
CORBA::Short	server_priority (void) const
bool	has_system_id (void) const
PortableServer::Servant	find_servant (const PortableServer::ObjectId &system_id)
TAO_SERVANT_LOCATION	servant_present (const PortableServer::ObjectId &system_id, PortableServer::Servant &servant)
PortableServer::Servant	find_servant (const PortableServer::ObjectId &system_id, TAO::Portable_Server::Servant_Upcall &servant_upcall, TAO::Portable_Server::POA_Current_Impl &poa_current_impl)
int	find_servant_priority (const PortableServer::ObjectId &system_id, CORBA::Short &priority)
int	unbind_using_user_id (const PortableServer::ObjectId &user_id)
void	cleanup_servant (PortableServer::Servant servant, const PortableServer::ObjectId &user_id)
void	post_invoke_servant_cleanup (const PortableServer::ObjectId &system_id, const TAO::Portable_Server::Servant_Upcall &servant_upcall)
bool	validate_lifespan (CORBA::Boolean is_persistent, const TAO::Portable_Server::Temporary_Creation_Time &creation_time) const
PortableServer::ObjectId *	activate_object_i (PortableServer::Servant p_servant, CORBA::Short priority, bool &wait_occurred_restart_call)
CORBA::Object_ptr	id_to_reference_i (const PortableServer::ObjectId &oid, bool indirect)
PortableServer::ObjectId *	servant_to_id_i (PortableServer::Servant servant)
TAO_SYNCH_CONDITION &	servant_deactivation_condition (void)
int	is_poa_generated_id (const PortableServer::ObjectId &id)
void	check_state (void)
	Check the state of this POA.
int	delete_child (const String &child)
PortableServer::Servant	user_id_to_servant_i (const PortableServer::ObjectId &oid)
virtual CORBA::ORB_ptr	_get_orb (void)
virtual void	poa_activated_hook ()
	Hook - The POA has been (or is being) activated.
virtual void	poa_deactivated_hook ()
	Hook - The POA has been deactivated.
virtual void	servant_activated_hook (PortableServer::Servant servant, const PortableServer::ObjectId &oid)
	Hook - A servant has been activated.
virtual void	servant_deactivated_hook (PortableServer::Servant servant, const PortableServer::ObjectId &oid)
	Hook - A servant has been deactivated.
CORBA::Object_ptr	invoke_key_to_object_helper_i (const char *repository_id, const PortableServer::ObjectId &id)
Static Public Member Functions
static char	name_separator (void)
static CORBA::ULong	name_separator_length (void)
static void	check_for_valid_wait_for_completions (const TAO_ORB_Core &orb_core, CORBA::Boolean wait_for_completion)
static int	parse_ir_object_key (const TAO::ObjectKey &object_key, PortableServer::ObjectId &user_id)
	Calls protected static method used when POACurrent is not appropriate.
static void	ort_adapter_factory_name (const char *name)
static const char *	ort_adapter_factory_name (void)
static void	imr_client_adapter_name (const char *name)
	Sets the value of TAO_POA_Static_Resources::imr_client_adapter_name_.
static const char *	imr_client_adapter_name (void)
	Gets the value of TAO_POA_Static_Resources::imr_client_adapter_name_.
Public Attributes
CORBA::ULong	caller_key_to_object_
PortableServer::Servant	servant_for_key_to_object_
Key_To_Object_Params	key_to_object_params_
Static Public Attributes
static CORBA::Octet const	objectkey_prefix [TAO_OBJECTKEY_PREFIX_SIZE]
Protected Types
typedef ACE_Hash_Map_Manager_Ex< ACE_CString, TAO_Root_POA *, ACE_Hash< ACE_CString >, ACE_Equal_To< ACE_CString >, ACE_Null_Mutex >	CHILDREN
Protected Member Functions
int	enter (void)
int	exit (void)
virtual TAO_Root_POA *	new_POA (const String &name, PortableServer::POAManager_ptr poa_manager, const TAO_POA_Policy_Set &policies, TAO_Root_POA *parent, ACE_Lock &lock, TAO_SYNCH_MUTEX &thread_lock, TAO_ORB_Core &orb_core, TAO_Object_Adapter *object_adapter)
	Template method for creating new POA's of this type.
PortableServer::POA_ptr	create_POA_i (const char *adapter_name, PortableServer::POAManager_ptr poa_manager, const CORBA::PolicyList &policies)
PortableServer::POA_ptr	create_POA_i (const String &adapter_name, PortableServer::POAManager_ptr poa_manager, const TAO_POA_Policy_Set &policies)
TAO_Root_POA *	find_POA_i (const ACE_CString &child_name, CORBA::Boolean activate_it)
void	destroy_i (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion)
void	complete_destruction_i (void)
PortableServer::POAList *	the_children_i (void)
PortableInterceptor::AdapterName *	adapter_name_i (void)
void	adapter_state_changed (const TAO::ORT_Array &array_obj_ref_template, PortableInterceptor::AdapterState state)
void	add_ior_component (TAO_MProfile &mprofile, const IOP::TaggedComponent &component)
	Add the given tagged component to all profiles.
void	add_ior_component_to_profile (TAO_MProfile &mprofile, const IOP::TaggedComponent &component, IOP::ProfileId profile_id)
CORBA::Object_ptr	key_to_object (const TAO::ObjectKey &key, const char *type_id, TAO_ServantBase *servant, CORBA::Boolean collocated, CORBA::Short priority, bool indirect)
virtual TAO_Stub *	key_to_stub_i (const TAO::ObjectKey &key, const char *type_id, CORBA::Short priority)
	Like key_to_stub() but assume that the ORB is not shutting down.
TAO_Stub *	create_stub_object (const TAO::ObjectKey &object_key, const char *type_id, CORBA::PolicyList *policy_list, TAO_Acceptor_Filter *filter, TAO_Acceptor_Registry &acceptor_registry)
PortableServer::Servant	get_servant_i (void)
void	activate_object_with_id_i (const PortableServer::ObjectId &id, PortableServer::Servant p_servant, CORBA::Short priority, bool &wait_occurred_restart_call)
virtual void	remove_from_parent_i (void)
void	deactivate_all_objects_i (CORBA::Boolean etherealize_objects)
void	deactivate_all_objects_i (CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion)
void	wait_for_completions (CORBA::Boolean wait_for_completion)
CORBA::Object_ptr	create_reference_i (const char *intf, CORBA::Short priority)
CORBA::Object_ptr	create_reference_with_id_i (const PortableServer::ObjectId &oid, const char *intf, CORBA::Short priority)
PortableServer::Servant	reference_to_servant_i (CORBA::Object_ptr reference)
CORBA::Object_ptr	servant_to_reference_i (PortableServer::Servant p_servant)
PortableServer::Servant	id_to_servant_i (const PortableServer::ObjectId &oid)
void	establish_components (void)
void	components_established (PortableInterceptor::IORInfo_ptr info)
void	set_folded_name (TAO_Root_POA *parent)
void	set_id (TAO_Root_POA *parent)
TAO::ObjectKey *	create_object_key (const PortableServer::ObjectId &id)
PortableInterceptor::ObjectReferenceTemplate *	get_adapter_template (void)
	Accessor methods to ObjectReferenceTemplate.
PortableInterceptor::ObjectReferenceTemplate *	get_adapter_template_i (void)
	Accessor methods to ObjectReferenceTemplate, non locked version.
PortableInterceptor::ObjectReferenceFactory *	get_obj_ref_factory (void)
	Accessor methods to PortableInterceptor::ObjectReferenceFactory.
void	set_obj_ref_factory (PortableInterceptor::ObjectReferenceFactory *current_factory)
	Set the object reference factory.
TAO_SERVANT_LOCATION	locate_servant_i (const PortableServer::ObjectId &id, PortableServer::Servant &servant)
PortableServer::Servant	locate_servant_i (const char *operation, const PortableServer::ObjectId &id, TAO::Portable_Server::Servant_Upcall &servant_upcall, TAO::Portable_Server::POA_Current_Impl &poa_current_impl, bool &wait_occurred_restart_call)
TAO::ORT_Adapter *	ORT_adapter (void)
TAO::ORT_Adapter *	ORT_adapter_i (void)
TAO::ORT_Adapter_Factory *	ORT_adapter_factory (void)
CORBA::Boolean	persistent (void)
virtual CORBA::Boolean	root (void) const
virtual char	root_key_type (void)
void	outstanding_requests (CORBA::ULong new_outstanding_requests)
CORBA::ULong	increment_outstanding_requests (void)
CORBA::ULong	decrement_outstanding_requests (void)
Static Protected Member Functions
static int	parse_key (const TAO::ObjectKey &key, TAO_Object_Adapter::poa_name &poa_system_name, PortableServer::ObjectId &system_id, CORBA::Boolean &is_root, CORBA::Boolean &is_persistent, CORBA::Boolean &is_system_id, TAO::Portable_Server::Temporary_Creation_Time &poa_creation_time)
static char	persistent_key_char (void)
static char	transient_key_char (void)
static CORBA::ULong	persistent_key_type_length (void)
static char	system_id_key_char (void)
static char	user_id_key_char (void)
static CORBA::ULong	system_id_key_type_length (void)
static char	root_key_char (void)
static char	non_root_key_char (void)
static CORBA::ULong	root_key_type_length (void)
Protected Attributes
String	name_
TAO_POA_Manager &	poa_manager_
	Reference to the POAManager that this poa assicuates with.
TAO_POAManager_Factory &	poa_manager_factory_
	Reference to the POAManagerFactory that generate the POAManager.
IOP::TaggedComponentSeq	tagged_component_
IOP::TaggedComponentSeq	tagged_component_id_
ACE_Array_Base< IOP::ProfileId >	profile_id_array_
TAO_POA_Policy_Set	policies_
TAO_Object_Adapter::poa_name	folded_name_
TAO_Object_Adapter::poa_name_var	system_name_
CORBA::OctetSeq	id_
TAO::ORT_Adapter *	ort_adapter_
	Pointer to the object reference template adapter.
PortableInterceptor::AdapterState	adapter_state_
	Adapter can be accepting, rejecting etc.
TAO::Portable_Server::Cached_Policies	cached_policies_
TAO_Network_Priority_Hook *	network_priority_hook_
TAO::Portable_Server::Active_Policy_Strategies	active_policy_strategies_
PortableServer::AdapterActivator_var	adapter_activator_
CHILDREN	children_
ACE_Lock &	lock_
TAO_ORB_Core &	orb_core_
TAO_Object_Adapter *	object_adapter_
	The object adapter we belong to.
CORBA::Boolean	cleanup_in_progress_
CORBA::ULong	outstanding_requests_
TAO_SYNCH_CONDITION	outstanding_requests_condition_
CORBA::Boolean	wait_for_completion_pending_
CORBA::Boolean	waiting_destruction_
TAO_SYNCH_CONDITION	servant_deactivation_condition_
TAO_Acceptor_Filter_Factory *	filter_factory_
Friends
class	TAO_Object_Adapter
class	TAO::Portable_Server::Servant_Upcall
class	TAO::Portable_Server::Non_Servant_Upcall
class	TAO_POA_Manager
class	TAO_RT_Collocation_Resolver
class	TAO_IORInfo
Classes
struct	Key_To_Object_Params

---

Detailed Description

Implementation of the PortableServer::POA interface.

Implementation of the PortableServer::POA interface.

Definition at line 114 of file Root_POA.h.

---

Member Typedef Documentation

typedef ACE_Hash_Map_Manager_Ex< ACE_CString, TAO_Root_POA *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex > TAO_Root_POA::CHILDREN [protected]

Definition at line 736 of file Root_POA.h.

typedef ACE_CString TAO_Root_POA::String

Definition at line 127 of file Root_POA.h.

---

Member Enumeration Documentation

anonymous enum

Enumerator:

TAO_OBJECTKEY_PREFIX_SIZE

Definition at line 277 of file Root_POA.h.

  {
    TAO_OBJECTKEY_PREFIX_SIZE = 4
  };

---

Constructor & Destructor Documentation

TAO_Root_POA::TAO_Root_POA	(	const String &	name,
		PortableServer::POAManager_ptr	poa_manager,
		const TAO_POA_Policy_Set &	policies,
		TAO_Root_POA *	parent,
		ACE_Lock &	lock,
		TAO_SYNCH_MUTEX &	thread_lock,
		TAO_ORB_Core &	orb_core,
		TAO_Object_Adapter *	object_adapter
	)

Definition at line 186 of file Root_POA.cpp.

References TAO::Portable_Server::Active_Policy_Strategies_Cleanup_Guard::_retn(), TAO_Objref_Var_T< T >::_retn(), active_policy_strategies_, TAO_Object_Adapter::bind_poa(), cached_policies_, filter_factory_, TAO::Portable_Server::Cached_Policies::implicit_activation(), ACE_Dynamic_Service< TYPE >::instance(), TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy(), network_priority_hook_, object_adapter(), poa_manager_, TAO_POA_Manager::register_poa(), TAO_POA_Manager::remove_poa(), set_folded_name(), set_id(), ACE_OS::strcmp(), TAO_DEFAULT_ROOTPOA_NAME, TAO_Object_Adapter::unbind_poa(), TAO::Portable_Server::Active_Policy_Strategies::update(), TAO::Portable_Server::Cached_Policies::update(), and TAO_Network_Priority_Hook::update_network_priority().

  : name_ (name),
    poa_manager_ (* (dynamic_cast <TAO_POA_Manager*> (poa_manager))),

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
    poa_manager_factory_ (* (object_adapter->poa_manager_factory_)),
#endif

    tagged_component_ (),
    tagged_component_id_ (),
    profile_id_array_ (0),
    policies_ (policies),
    ort_adapter_ (0),
    adapter_state_ (PortableInterceptor::HOLDING),
    network_priority_hook_ (0),
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
    adapter_activator_ (),
#endif /* TAO_HAS_MINIMUM_POA == 0 */
    children_ (),
    lock_ (lock),
    orb_core_ (orb_core),
    object_adapter_ (object_adapter),
    cleanup_in_progress_ (false),
    outstanding_requests_ (0),
    outstanding_requests_condition_ (thread_lock),
    wait_for_completion_pending_ (0),
    waiting_destruction_ (false),
    servant_deactivation_condition_ (thread_lock),
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
    filter_factory_ (0),
#endif
    caller_key_to_object_ (0),
    servant_for_key_to_object_ (0)
{
  // Since we are keeping a reference to a POAManager, we need to
  // increment the reference count but we do this safely.
  PortableServer::POAManager_var pm_guard (
    PortableServer::POAManager::_duplicate(&this->poa_manager_));

  // Parse the policies that are used in the critical path in
  // a cache.
  this->cached_policies_.update (this->policies_);

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
  this->filter_factory_
    = ACE_Dynamic_Service<TAO_Acceptor_Filter_Factory>::instance (
        "TAO_Acceptor_Filter_Factory");
#endif

  this->network_priority_hook_
    = ACE_Dynamic_Service<TAO_Network_Priority_Hook>::instance (
        "TAO_Network_Priority_Hook");

  if (this->network_priority_hook_ != 0)
    {
      this->network_priority_hook_->update_network_priority (
        *this, this->policies_);
    }

#if (TAO_HAS_MINIMUM_POA == 1)
  // If this is the RootPOA, set the value of the ImplicitActivationPolicy
  // to IMPLICIT_ACTIVATION since it is impossible to pass the policy
  // as it is not compiled into the library.
  //
  // If the ImplicitActivationPolicy policy is ever compiled in the
  // minimum POA builds, remove this code and remove the guards
  // in Object_Adapter.cpp when changing the default policy for the
  // RootPOA.
  if (ACE_OS::strcmp (this->name_.c_str (),
                      TAO_DEFAULT_ROOTPOA_NAME) == 0)
    {
      this->cached_policies_.implicit_activation
        (PortableServer::IMPLICIT_ACTIVATION);
    }
#endif /* TAO_HAS_MINIMUM_POA == 1 */

  // Set the active strategies to be used by this POA
  this->active_policy_strategies_.update (this->cached_policies_,
                                          this);
  TAO::Portable_Server::Active_Policy_Strategies_Cleanup_Guard aps_cleanup_guard (
    &this->active_policy_strategies_);

  // Set the folded name of this POA.
  this->set_folded_name (parent);

  // Register self with manager.
  int result = this->poa_manager_.register_poa (this);
  if (result != 0)
    {
      throw ::CORBA::OBJ_ADAPTER ();
    }

  // Add self to Object Adapter class.
  result =
    this->object_adapter ().bind_poa (this->folded_name_,
                                      this,
                                      this->system_name_.out ());
  if (result != 0)
    {
      // Remove from POA Manager in case of errors. No checks of
      // further errors...
      this->poa_manager_.remove_poa (this);

      throw ::CORBA::OBJ_ADAPTER ();
    }

  // Set the id for this POA.
  this->set_id (parent);

  // Notify the Lifespan strategy of our startup
  try
    {
      this->active_policy_strategies_.lifespan_strategy()->notify_startup ();
    }
  catch (const ::CORBA::Exception&)
    {
      this->poa_manager_.remove_poa (this);
      this->object_adapter ().unbind_poa (this,
                                          this->folded_name_,
                                          this->system_name_.in ());
      throw;
    }

  // Now when everything is fine we can release the quards.
  pm_guard._retn ();
  aps_cleanup_guard._retn ();
}

TAO_Root_POA::~TAO_Root_POA

(

void

)

[virtual]

Definition at line 321 of file Root_POA.cpp.

References CORBA::Object::_remove_ref(), and poa_manager_.

{
  this->poa_manager_._remove_ref();
}

---

Member Function Documentation

CORBA::ORB_ptr TAO_Root_POA::_get_orb

(

void

)

[virtual]

Reimplemented from CORBA::LocalObject.

Definition at line 2670 of file Root_POA.cpp.

References CORBA::ORB::_duplicate().

{
  return CORBA::ORB::_duplicate (this->orb_core_.orb ());
}

PortableServer::ObjectId * TAO_Root_POA::activate_object

(

PortableServer::Servant

p_servant

)

Definition at line 1134 of file Root_POA.cpp.

References activate_object_i(), and TAO_POA_GUARD_RETURN.

Referenced by activate_object_i().

{
  while (1)
    {
      bool wait_occurred_restart_call = false;

      // Lock access for the duration of this transaction.
      TAO_POA_GUARD_RETURN (0);

      PortableServer::ObjectId *result =
        this->activate_object_i (servant,
                                 this->server_priority (),
                                 wait_occurred_restart_call);

      // If we ended up waiting on a condition variable, the POA state
      // may have changed while we are waiting.  Therefore, we need to
      // restart this call.
      if (wait_occurred_restart_call)
        continue;
      else
        return result;
    }
}

PortableServer::ObjectId * TAO_Root_POA::activate_object_i	(	PortableServer::Servant	p_servant,
		CORBA::Short	priority,
		bool &	wait_occurred_restart_call
	)

Definition at line 1123 of file Root_POA.cpp.

References activate_object(), active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by activate_object().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    activate_object (servant,
                     priority,
                     wait_occurred_restart_call);
}

void TAO_Root_POA::activate_object_with_id	(	const PortableServer::ObjectId &	id,
		PortableServer::Servant	p_servant
	)

Definition at line 1160 of file Root_POA.cpp.

References activate_object_with_id_i(), and TAO_POA_GUARD.

Referenced by activate_object_with_id_i().

{
  while (1)
    {
      bool wait_occurred_restart_call = false;

      // Lock access for the duration of this transaction.
      TAO_POA_GUARD;

      this->activate_object_with_id_i (id,
                                       servant,
                                       this->server_priority (),
                                       wait_occurred_restart_call);

      // If we ended up waiting on a condition variable, the POA state
      // may have changed while we are waiting.  Therefore, we need to
      // restart this call.
      if (wait_occurred_restart_call)
        continue;
      else
        return;
    }
}

void TAO_Root_POA::activate_object_with_id_i	(	const PortableServer::ObjectId &	id,
		PortableServer::Servant	p_servant,
		CORBA::Short	priority,
		bool &	wait_occurred_restart_call
	)			[protected]

Definition at line 1188 of file Root_POA.cpp.

References activate_object_with_id(), active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by activate_object_with_id().

{
  this->active_policy_strategies_.servant_retention_strategy()->
    activate_object_with_id (id,
                             servant,
                             priority,
                             wait_occurred_restart_call);
}

ACE_INLINE PortableInterceptor::AdapterName * TAO_Root_POA::adapter_name

(

void

)

This method returns the adapter_name as a sequence of strings of length one or more or just a fixed name depending on the Object Adapter. Added wrt to ORT Spec.

Definition at line 32 of file Root_POA.inl.

References adapter_name_i().

Referenced by create_POA_i(), and ORT_adapter_i().

{
  return this->adapter_name_i ();
}

PortableInterceptor::AdapterName * TAO_Root_POA::adapter_name_i

(

void

)

[protected]

This method returns the adapter_name as a sequence of strings of length one or more or just a fixed name depending on the Object Adapter. Added wrt to ORT Spec.

Definition at line 1008 of file Root_POA.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_ASSERT, ACE_NEW_THROW_EX, CORBA::COMPLETED_NO, TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), CORBA::string_dup(), and TAO::VMCID.

Referenced by adapter_name(), and ORT_adapter_i().

{
  // The adapter name is the sequence of names starting from the
  // RootPOA to the one whose name is requested.  The name of the
  // RootPOA is "RootPOA".

  PortableServer::POA_var poa = PortableServer::POA::_duplicate (this);

  CORBA::ULong len = 0;

  // Find the length of the adapter name sequence by traversing the
  // POA hierarchy until the RootPOA is reached.  The RootPOA has no
  // parent.
  while (!CORBA::is_nil (poa.in ()))
    {
      poa = poa->the_parent ();
      ++len;
    }

  // Empty adapter name sequence.
  PortableInterceptor::AdapterName *names = 0;
  ACE_NEW_THROW_EX (names,
                    PortableInterceptor::AdapterName (len),
                    CORBA::NO_MEMORY (
                      CORBA::SystemException::_tao_minor_code (
                        TAO::VMCID,
                        ENOMEM),
                      CORBA::COMPLETED_NO));

  PortableInterceptor::AdapterName_var safe_names (names);

  names->length (len);

  poa = PortableServer::POA::_duplicate (this);

  (*names)[0] = CORBA::string_dup ("RootPOA");

  // Fill in the AdapterName sequence as the POA hierarchy is
  // traversed.
  CORBA::ULong ilen = len;
  for (CORBA::ULong i = 1; i < len; ++i)
    {
      (*names)[--ilen] = poa->the_name ();

      poa = poa->the_parent ();

      // If this condition asserts, the POA hierarchy was modified
      // (i.e. reduced in size) by another thread!
      ACE_ASSERT ((ilen > 0 ? !CORBA::is_nil (poa.in ()) : 1));
    }

  return safe_names._retn ();
}

void TAO_Root_POA::adapter_state_changed	(	const TAO::ORT_Array &	array_obj_ref_template,
		PortableInterceptor::AdapterState	state
	)			[protected]

Method to notify the IOR Interceptors when there is a state changed not related to POAManager.

Definition at line 1109 of file Root_POA.cpp.

References TAO_IORInterceptor_Adapter::adapter_state_changed(), TAO_ORB_Core::ior_interceptor_adapter(), and orb_core_.

Referenced by complete_destruction_i(), and destroy_i().

{
  TAO_IORInterceptor_Adapter *ior_adapter =
    this->orb_core_.ior_interceptor_adapter ();

  if (ior_adapter)
    {
      ior_adapter->adapter_state_changed (array_obj_ref_template, state);
    }
}

void TAO_Root_POA::add_ior_component	(	TAO_MProfile &	mprofile,
		const IOP::TaggedComponent &	component
	)			[protected]

Add the given tagged component to all profiles.

Definition at line 1063 of file Root_POA.cpp.

References TAO_Profile::add_tagged_component(), TAO_MProfile::get_profile(), and TAO_MProfile::profile_count().

{
  // Add the given tagged component to all profiles.
  const CORBA::ULong profile_count = mprofile.profile_count ();

  for (CORBA::ULong i = 0; i < profile_count; ++i)
    {
      TAO_Profile *profile = mprofile.get_profile (i);

      profile->add_tagged_component (component);
    }
}

void TAO_Root_POA::add_ior_component_to_profile	(	TAO_MProfile &	mprofile,
		const IOP::TaggedComponent &	component,
		IOP::ProfileId	profile_id
	)			[protected]

Add the given tagged component to all profiles matching the given ProfileId.

Definition at line 1078 of file Root_POA.cpp.

References TAO_Profile::add_tagged_component(), CORBA::COMPLETED_NO, TAO_MProfile::get_profile(), CORBA::OMGVMCID, and TAO_MProfile::profile_count().

{
  // Add the given tagged component to all profiles matching the given
  // ProfileId.
  bool found_profile = false;

  CORBA::ULong const profile_count = mprofile.profile_count ();

  for (CORBA::ULong i = 0; i < profile_count; ++i)
    {
      TAO_Profile *profile = mprofile.get_profile (i);

      if (profile->tag () == profile_id)
        {
          profile->add_tagged_component (component);

          found_profile = true;
        }
    }

  // According to the Portable Interceptor specification, we're
  // supposed to throw a CORBA::BAD_PARAM exception if no profile
  // matched the given ProfileId.
  if (found_profile == false)
    throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 29, CORBA::COMPLETED_NO);
}

bool TAO_Root_POA::allow_implicit_activation

(

void

)

const

Definition at line 2485 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::implicit_activation_strategy().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_system_id_i(), and TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_user_id().

{
  return this->active_policy_strategies_.implicit_activation_strategy ()->
    allow_implicit_activation ();
}

bool TAO_Root_POA::allow_multiple_activations

(

void

)

const

Definition at line 2492 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::id_uniqueness_strategy().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::strategy_init().

{
  return this->active_policy_strategies_.id_uniqueness_strategy ()->
    allow_multiple_activations ();
}

TAO::Portable_Server::Cached_Policies & TAO_Root_POA::cached_policies

(

void

)

obtain a reference to the cached_profiles

Definition at line 2523 of file Root_POA.cpp.

References cached_policies_.

Referenced by TAO_Network_Priority_Hook::update_network_priority().

{
  return this->cached_policies_;
}

void TAO_Root_POA::check_for_valid_wait_for_completions	(	const TAO_ORB_Core &	orb_core,
		CORBA::Boolean	wait_for_completion
	)			[static]

Definition at line 1229 of file Root_POA.cpp.

References CORBA::COMPLETED_NO, TAO_TSS_Resources::instance(), CORBA::OMGVMCID, TAO::Portable_Server::POA_Current_Impl::orb_core(), orb_core(), TAO_TSS_Resources::poa_current_impl_, and TAO::Portable_Server::POA_Current_Impl::previous_current_impl_.

Referenced by TAO_Object_Adapter::check_close(), TAO_POA_Manager::deactivate_i(), destroy_i(), TAO_POA_Manager::discard_requests_i(), and TAO_POA_Manager::hold_requests_i().

{
  if (wait_for_completion)
    {
      TAO::Portable_Server::POA_Current_Impl *poa_current_impl =
        static_cast <TAO::Portable_Server::POA_Current_Impl *>
                    (TAO_TSS_Resources::instance ()->poa_current_impl_);

      while (1)
        {
          // If wait_for_completion is TRUE and the current thread is
          // in an invocation context dispatched from some POA
          // belonging to the same ORB as this POA, the BAD_INV_ORDER
          // system exception with standard minor code 3 is raised and
          // POA destruction does not occur.
          if (poa_current_impl != 0)
            {
              if (&orb_core == &poa_current_impl->orb_core ())
                {
                  // CORBA 2.3 specifies which minor code corresponds
                  // to this particular problem.
                  throw ::CORBA::BAD_INV_ORDER (CORBA::OMGVMCID | 3,
                                                CORBA::COMPLETED_NO);
                }
            }
          else
            break;

          poa_current_impl =
            poa_current_impl->previous_current_impl_;
        }
    }
}

void TAO_Root_POA::check_state

(

void

)

Check the state of this POA.

Definition at line 2632 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy().

Referenced by find_POA_i(), and TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i().

{
  this->active_policy_strategies_.lifespan_strategy ()->check_state ();
}

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE CORBA::Boolean TAO_Root_POA::cleanup_in_progress

(

void

)

Definition at line 8 of file Root_POA.inl.

References cleanup_in_progress_.

Referenced by TAO::Portable_Server::POA_Guard::POA_Guard().

{
  return this->cleanup_in_progress_;
}

void TAO_Root_POA::cleanup_servant	(	PortableServer::Servant	servant,
		const PortableServer::ObjectId &	user_id
	)

Definition at line 1504 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::deactivate_map_entry(), and TAO::Portable_Server::Servant_Upcall::servant_cleanup().

{
  this->active_policy_strategies_.request_processing_strategy()->
    cleanup_servant (servant, user_id);
}

CORBA::PolicyList * TAO_Root_POA::client_exposed_policies

(

CORBA::Short

object_priority

)

[virtual]

This method gives the policies that are exposed to the client. These policies are shipped within the IOR.

Definition at line 2249 of file Root_POA.cpp.

References ACE_NEW_THROW_EX, TAO_POA_Policy_Set::add_client_exposed_fixed_policies(), CORBA::COMPLETED_NO, policies(), policies_, and TAO::VMCID.

Referenced by key_to_stub_i().

{
  CORBA::PolicyList *client_exposed_policies = 0;
  ACE_NEW_THROW_EX (client_exposed_policies,
                    CORBA::PolicyList (),
                    CORBA::NO_MEMORY (TAO::VMCID,
                                      CORBA::COMPLETED_NO));

  CORBA::PolicyList_var policies = client_exposed_policies;

  // Add in all of the client exposed policies.
  this->policies_.add_client_exposed_fixed_policies (client_exposed_policies);

  return policies._retn ();
}

void TAO_Root_POA::complete_destruction_i

(

void

)

[protected]

Definition at line 327 of file Root_POA.cpp.

References active_policy_strategies_, adapter_activator_, adapter_state_, adapter_state_changed(), TAO::Portable_Server::Active_Policy_Strategies::cleanup(), object_adapter(), ort_adapter_, ORT_adapter_factory(), ORT_adapter_i(), release(), TAO_Object_Adapter::unbind_poa(), and waiting_destruction_.

Referenced by destroy_i(), and TAO::Portable_Server::Servant_Upcall::poa_cleanup().

{
  bool doing_complete_destruction =
    this->waiting_destruction_ != false;

  // No longer awaiting destruction.
  this->waiting_destruction_ = false;

  PortableServer::POA_var poa;
  TAO::ORT_Array my_array_obj_ref_template;
  TAO::ORT_Adapter *ort_adapter = 0;
  if (doing_complete_destruction)
    {
      ort_adapter =
        this->ORT_adapter_i ();

      // In case no ORT library is linked we get zero.
      if (ort_adapter != 0)
        {
          // Get the ObjectReferenceTemplate.
          PortableInterceptor::ObjectReferenceTemplate * const ort =
            ort_adapter->get_adapter_template ();

          // Add it to the sequence of object reference templates, we
          // just notify for ourselves that we are now non_existent,
          // our childs will do it for themselves.
          my_array_obj_ref_template.size (1);
          my_array_obj_ref_template[0] = ort;
        }

      poa = PortableServer::POA::_duplicate (this);
    }

  // Remove POA from the POAManager.
  if (this->poa_manager_.remove_poa (this) != 0)
    throw ::CORBA::OBJ_ADAPTER ();

  // Remove POA from the Object Adapter.
  int result = this->object_adapter ().unbind_poa (this,
                                                   this->folded_name_,
                                                   this->system_name_.in ());
  if (result != 0)
    throw ::CORBA::OBJ_ADAPTER ();

  // Cleanup all strategies
  this->active_policy_strategies_.cleanup ();

  // Forced cleanup.  The new memory management scheme is evil and can
  // lead to reference deadlock, i.e., POA holds object A, but POA
  // cannot die because object A hold POA.
  {
    //
    // If new things are added to this cleanup code, make sure to move
    // the minimum CORBA #define after the declaration of
    // <non_servant_upcall>.
    //

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)

    // ATTENTION: Trick locking here, see class header for details
    TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*this);
    ACE_UNUSED_ARG (non_servant_upcall);

    this->adapter_activator_ = PortableServer::AdapterActivator::_nil ();

#endif /* TAO_HAS_MINIMUM_POA == 0 */

  }

  ::CORBA::release (this);

  if (doing_complete_destruction)
    {
      this->adapter_state_ = PortableInterceptor::NON_EXISTENT;

      this->adapter_state_changed (my_array_obj_ref_template,
                                   this->adapter_state_);

      if (ort_adapter != 0)
        {
          ort_adapter->release (my_array_obj_ref_template[0]);

          TAO::ORT_Adapter_Factory *ort_factory =
            this->ORT_adapter_factory ();

          ort_factory->destroy (ort_adapter);

          this->ort_adapter_ = 0;
        }
    }
}

void TAO_Root_POA::components_established

(

PortableInterceptor::IORInfo_ptr

info

)

[protected]

Call the IORInterceptor::components_established() method on all registered IORInterceptors.

Definition at line 2127 of file Root_POA.cpp.

References TAO_IORInterceptor_Adapter::components_established(), TAO_ORB_Core::ior_interceptor_adapter(), and orb_core_.

{
  TAO_IORInterceptor_Adapter *ior_adapter =
    this->orb_core_.ior_interceptor_adapter ();

  if (ior_adapter)
    {
      ior_adapter->components_established (info);
    }
}

PortableServer::IdAssignmentPolicy_ptr TAO_Root_POA::create_id_assignment_policy

(

PortableServer::IdAssignmentPolicyValue

value

)

Definition at line 125 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::IdAssignmentPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::IdAssignmentPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

PortableServer::IdUniquenessPolicy_ptr TAO_Root_POA::create_id_uniqueness_policy

(

PortableServer::IdUniquenessPolicyValue

value

)

Definition at line 112 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::IdUniquenessPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::IdUniquenessPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

PortableServer::ImplicitActivationPolicy_ptr TAO_Root_POA::create_implicit_activation_policy

(

PortableServer::ImplicitActivationPolicyValue

value

)

Definition at line 139 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::ImplicitActivationPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::ImplicitActivationPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

PortableServer::LifespanPolicy_ptr TAO_Root_POA::create_lifespan_policy

(

PortableServer::LifespanPolicyValue

value

)

Definition at line 98 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::LifespanPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::LifespanPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

TAO::ObjectKey * TAO_Root_POA::create_object_key

(

const PortableServer::ObjectId &

id

)

[protected]

Definition at line 1716 of file Root_POA.cpp.

References ACE_NEW_RETURN, id_, and ACE_OS::memcpy().

Referenced by invoke_key_to_object().

{
  // Calculate the space required for the key.
  CORBA::ULong buffer_size =
    this->id_.length () +
    id.length ();

  // Create the buffer for the key.
  CORBA::Octet *buffer = TAO::ObjectKey::allocbuf (buffer_size);

  // First copy the POA id into the key.
  ACE_OS::memcpy (&buffer[0],
                  this->id_.get_buffer (),
                  this->id_.length ());

  // Then copy the object id into the key.
  ACE_OS::memcpy (&buffer[this->id_.length ()],
                  id.get_buffer (),
                  id.length ());

  // Create the key, giving the ownership of the buffer to the
  // sequence.
  TAO::ObjectKey *key = 0;
  ACE_NEW_RETURN (key,
                  TAO::ObjectKey (buffer_size,
                                  buffer_size,
                                  buffer,
                                  1),
                  0);

  return key;
}

PortableServer::POA_ptr TAO_Root_POA::create_POA	(	const char *	adapter_name,
		PortableServer::POAManager_ptr	poa_manager,
		const CORBA::PolicyList &	policies
	)

Definition at line 700 of file Root_POA.cpp.

References create_POA_i(), and TAO_POA_GUARD_RETURN.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->create_POA_i (adapter_name, poa_manager, policies);
}

PortableServer::POA_ptr TAO_Root_POA::create_POA_i	(	const String &	adapter_name,
		PortableServer::POAManager_ptr	poa_manager,
		const TAO_POA_Policy_Set &	policies
	)			[protected]

Definition at line 527 of file Root_POA.cpp.

References CORBA::Object::_add_ref(), adapter_name(), establish_components(), new_POA(), object_adapter(), object_adapter_, orb_core_, policies(), and TAO_Object_Adapter::thread_lock().

{
  // This operaton creates a new POA as a child of the target POA. The
  // specified name identifies the new POA with respect to other POAs
  // with the same parent POA. If the target POA already has a child
  // POA with the specified name, the AdapterAlreadyExists exception
  // is raised.
  // Child was found
  if (this->children_.find (adapter_name) != -1)
    {
      throw PortableServer::POA::AdapterAlreadyExists ();
    }

  //
  // Child was not found.  Create one.
  //

  // The specified policy objects are associated with the POA and used
  // to control its behavior. The policy objects are effectively
  // copied before this operation returns, so the application is free
  // to destroy them while the POA is in use. Policies are not
  // inherited from the parent POA.
  TAO_Root_POA * poa = this->new_POA (adapter_name,
                                      poa_manager,
                                      policies,
                                      this,
                                      this->object_adapter ().lock (),
                                      this->object_adapter ().thread_lock (),
                                      this->orb_core_,
                                      this->object_adapter_);

  // Give ownership of the new map to the POA_var.  Note, that it
  // is important for the POA_var to take ownership before
  // checking for exception since we may need to delete the new map.
  PortableServer::POA_var new_poa = poa;

  // Check for exception in construction of the POA.

  // Add to children map
  if (this->children_.bind (adapter_name, poa) != 0)
    {
      throw ::CORBA::OBJ_ADAPTER ();
    }

  // Increment the reference count on the child POA since the children
  // map must retain ownership.  Do so immediately before any other
  // operations to prevent memory cleanup problems induced from
  // errors below.
  poa->_add_ref ();

  // Iterate over the registered IOR interceptors so that they may be
  // given the opportunity to add tagged components to the profiles
  // for this servant.
  poa->establish_components ();

  // Note: Creating a POA using a POA manager that is in the active
  // state can lead to race conditions if the POA supports preexisting
  // objects, because the new POA may receive a request before its
  // adapter activator, servant manager, or default servant have been
  // initialized. These problems do not occur if the POA is created by
  // an adapter activator registered with a parent of the new POA,
  // because requests are queued until the adapter activator
  // returns. To avoid these problems when a POA must be explicitly
  // initialized, the application can initialize the POA by invoking
  // find_POA with a TRUE activate parameter.

  // Everything is fine. Don't let the POA_var release the
  // implementation.
  return new_poa._retn ();
}

PortableServer::POA_ptr TAO_Root_POA::create_POA_i	(	const char *	adapter_name,
		PortableServer::POAManager_ptr	poa_manager,
		const CORBA::PolicyList &	policies
	)			[protected]

Definition at line 421 of file Root_POA.cpp.

References TAO_Objref_Var_T< T >::_retn(), ACE_NEW_THROW_EX, TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), TAO_Policy_Validator::merge_policies(), object_adapter(), orb_core_, and TAO_Object_Adapter::validator().

Referenced by create_POA().

{
  // Initialize a TAO_POA_Policy_Set instance so that it contains the
  // default POA policies.
  TAO_POA_Policy_Set tao_policies (this->object_adapter ().default_poa_policies ());

  // Merge policies from the ORB level.
  this->object_adapter ().validator ().merge_policies (tao_policies.policies ());

  // Merge in any policies that the user may have specified.
  tao_policies.merge_policies (policies);

  // If any of the policy objects specified are not valid for the ORB
  // implementation, if conflicting policy objects are specified, or
  // if any of the specified policy objects require prior
  // administrative action that has not been performed, an
  // InvalidPolicy exception is raised containing the index in the
  // policies parameter value of the first offending policy object.
  tao_policies.validate_policies (this->object_adapter ().validator (),
                                  this->orb_core_);

  // If the poa_manager parameter is null, a new POAManager object is
  // created and associated with the new POA. Otherwise, the specified
  // POAManager object is associated with the new POA. The POAManager
  // object can be obtained using the attribute name the_POAManager.

  PortableServer::POAManager_var the_poa_manager;

  if (CORBA::is_nil (poa_manager))
    {
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)

      PortableServer::POA_var poa = PortableServer::POA::_duplicate (this);
      PortableServer::POA_var root_poa;

      // Find the RootPOA by traversing the POA hierarchy until the
      // RootPOA is reached.  The RootPOA has no parent.
      while (!CORBA::is_nil (poa.in ()))
      {
        root_poa = poa;
        poa = poa->the_parent ();
      }

      // Get the POAManagerFactory instance owned by RootPOA.
      PortableServer::POAManagerFactory_var tao_poa_manager_factory
        = root_poa->the_POAManagerFactory ();

      CORBA::PolicyList empty_policies;

      // The POAManager name will be generated when the POAManager instance
      // is created.
      the_poa_manager
        = tao_poa_manager_factory->create_POAManager (0, empty_policies);
#else

      PortableServer::POAManager_ptr the_poa_manager_ptr;
      ACE_NEW_THROW_EX (the_poa_manager_ptr,
                        TAO_POA_Manager (this->object_adapter (), 0),
                        CORBA::NO_MEMORY ());
      the_poa_manager = the_poa_manager_ptr;
#endif /* TAO_HAS_MINIMUM_POA == 0 && ! CORBA_E_COMPACT) */

    }
  else
    {
      the_poa_manager = PortableServer::POAManager::_duplicate (poa_manager);
    }

  PortableServer::POA_var poa = this->create_POA_i (adapter_name,
                                                    the_poa_manager.in (),
                                                    tao_policies);

  return poa._retn ();
}

CORBA::Object_ptr TAO_Root_POA::create_reference

(

const char *

intf

)

Definition at line 1298 of file Root_POA.cpp.

References CORBA::Object::_nil(), create_reference_i(), and TAO_POA_GUARD_RETURN.

Referenced by create_reference_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (CORBA::Object::_nil ());

  return this->create_reference_i (intf,
                                   this->server_priority ());
}

CORBA::Object_ptr TAO_Root_POA::create_reference_i	(	const char *	intf,
		CORBA::Short	priority
	)			[protected]

Definition at line 1308 of file Root_POA.cpp.

References active_policy_strategies_, create_reference(), and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by create_reference().

{
  if (!this->has_system_id ())
    {
      throw PortableServer::POA::WrongPolicy ();
    }

  return this->active_policy_strategies_.servant_retention_strategy()->
    create_reference (intf, priority);
}

CORBA::Object_ptr TAO_Root_POA::create_reference_with_id	(	const PortableServer::ObjectId &	oid,
		const char *	intf
	)

Definition at line 777 of file Root_POA.cpp.

References CORBA::Object::_nil(), create_reference_with_id_i(), and TAO_POA_GUARD_RETURN.

Referenced by create_reference_with_id_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (CORBA::Object::_nil ());

  return this->create_reference_with_id_i (id,
                                           intf,
                                           this->server_priority ());
}

CORBA::Object_ptr TAO_Root_POA::create_reference_with_id_i	(	const PortableServer::ObjectId &	oid,
		const char *	intf,
		CORBA::Short	priority
	)			[protected]

Definition at line 1342 of file Root_POA.cpp.

References active_policy_strategies_, CORBA::COMPLETED_NO, create_reference_with_id(), is_poa_generated_id(), CORBA::OMGVMCID, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by create_reference_with_id().

{
  // If the POA has the SYSTEM_ID policy and it detects that the
  // Object Id value was not generated by the system or for this POA,
  // the create_reference_with_id operation may raise the BAD_PARAM
  // system exception. An ORB is not required to detect all such
  // invalid Object Id values, but a portable application must not
  // invoke this operation on a POA that has the SYSTEM_ID policy with
  // an Object Id value that was not previously generated by the
  // system for that POA, or, if the POA also has the PERSISTENT
  // policy, for a previous instantiation of the same POA.
  if (this->has_system_id () &&
      !this->is_poa_generated_id (user_id))
    {
      throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 14, CORBA::COMPLETED_NO);
    }

  return this->active_policy_strategies_.servant_retention_strategy()->
    create_reference_with_id (user_id, intf, priority);
}

PortableServer::RequestProcessingPolicy_ptr TAO_Root_POA::create_request_processing_policy

(

PortableServer::RequestProcessingPolicyValue

value

)

Definition at line 161 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::RequestProcessingPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::RequestProcessingPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

PortableServer::ServantRetentionPolicy_ptr TAO_Root_POA::create_servant_retention_policy

(

PortableServer::ServantRetentionPolicyValue

value

)

Definition at line 150 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::ServantRetentionPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::ServantRetentionPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

TAO_Stub * TAO_Root_POA::create_stub_object	(	const TAO::ObjectKey &	object_key,
		const char *	type_id,
		CORBA::PolicyList *	policy_list,
		TAO_Acceptor_Filter *	filter,
		TAO_Acceptor_Registry &	acceptor_registry
	)			[protected]

Definition at line 2170 of file Root_POA.cpp.

References CORBA::SystemException::_tao_minor_code(), TAO_Acceptor_Registry::begin(), CORBA::COMPLETED_NO, TAO_ORB_Core::create_stub_object(), TAO_Acceptor_Filter::encode_endpoints(), TAO_Acceptor_Registry::end(), TAO_Acceptor_Registry::endpoint_count(), TAO_Acceptor_Filter::fill_profile(), orb_core_, TAO_MProfile::profile_count(), TAO_MProfile::set(), tagged_component_, tagged_component_id_, and TAO_MPROFILE_CREATION_ERROR.

Referenced by key_to_stub_i().

{
  bool error = false;

  // Count the number of endpoints.
  size_t const profile_count = acceptor_registry.endpoint_count ();

  // Create a profile container and have acceptor registries populate
  // it with profiles as appropriate.
  TAO_MProfile mprofile (0);

  // Allocate space for storing the profiles.  There can never be more
  // profiles than there are endpoints.  In some cases, there can be
  // less profiles than endpoints.
  int result = mprofile.set (static_cast <CORBA::ULong> (profile_count));
  if (result == -1)
    error = true;

  if (!error)
    {
      result =
        filter->fill_profile (object_key,
                              mprofile,
                              acceptor_registry.begin (),
                              acceptor_registry.end ());
      if (result == -1)
        error = true;
    }

  if (!error)
    result = filter->encode_endpoints (mprofile);

  if (result == -1)
    error = true;

  if (error)
    throw ::CORBA::INTERNAL (
      CORBA::SystemException::_tao_minor_code (
        TAO_MPROFILE_CREATION_ERROR,
        0),
      CORBA::COMPLETED_NO);

  // Make sure we have at least one profile.  <mp> may end up being
  // empty if none of the acceptor endpoints have the right priority
  // for this object, for example.
  if (mprofile.profile_count () == 0)
    throw ::CORBA::BAD_PARAM (
      CORBA::SystemException::_tao_minor_code (
        TAO_MPROFILE_CREATION_ERROR,
        0),
      CORBA::COMPLETED_NO);

  TAO_Stub *stub =
    this->orb_core_.create_stub_object (mprofile, type_id, policy_list);

  // Add the saved tagged components methods to the profiles.
  CORBA::ULong len = this->tagged_component_.length ();
  for (CORBA::ULong i = 0; i != len; ++i)
    {
      this->add_ior_component (mprofile, this->tagged_component_[i]);
      }

  len = this->tagged_component_id_.length ();

  for (CORBA::ULong k = 0; k != len; ++k)
    {
      this->add_ior_component_to_profile (mprofile,
                                          this->tagged_component_id_[k],
                                          this->profile_id_array_[k]);
    }

  return stub;
}

PortableServer::ThreadPolicy_ptr TAO_Root_POA::create_thread_policy

(

PortableServer::ThreadPolicyValue

value

)

Definition at line 83 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  TAO::Portable_Server::ThreadPolicy *policy = 0;
  ACE_NEW_THROW_EX (policy,
                    TAO::Portable_Server::ThreadPolicy (value),
                    CORBA::NO_MEMORY ());

  return policy;
}

void TAO_Root_POA::deactivate_all_objects_i	(	CORBA::Boolean	etherealize_objects,
		CORBA::Boolean	wait_for_completion
	)			[protected]

Definition at line 1202 of file Root_POA.cpp.

References deactivate_all_objects_i(), and wait_for_completions().

{
  this->deactivate_all_objects_i (etherealize_objects);

  this->wait_for_completions (wait_for_completion);
}

void TAO_Root_POA::deactivate_all_objects_i

(

CORBA::Boolean

etherealize_objects

)

[protected]

Definition at line 1265 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by deactivate_all_objects_i(), and destroy_i().

{
  this->active_policy_strategies_.request_processing_strategy ()->
    etherealize_objects (etherealize_objects);

  this->active_policy_strategies_.servant_retention_strategy ()->
    deactivate_all_objects ();
}

void TAO_Root_POA::deactivate_object

(

const PortableServer::ObjectId &

oid

)

Definition at line 1275 of file Root_POA.cpp.

References deactivate_object_i(), and TAO_POA_GUARD.

Referenced by deactivate_object_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD;

  this->deactivate_object_i (oid);
}

void TAO_Root_POA::deactivate_object_i

(

const PortableServer::ObjectId &

oid

)

Definition at line 1285 of file Root_POA.cpp.

References active_policy_strategies_, deactivate_object(), and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by deactivate_object().

{
  this->active_policy_strategies_.servant_retention_strategy()->
    deactivate_object (id);
}

ACE_INLINE CORBA::ULong TAO_Root_POA::decrement_outstanding_requests

(

void

)

[protected]

Definition at line 201 of file Root_POA.inl.

References outstanding_requests_.

Referenced by TAO::Portable_Server::Servant_Upcall::poa_cleanup().

{
  return --this->outstanding_requests_;
}

int TAO_Root_POA::delete_child

(

const String &

child

)

Definition at line 967 of file Root_POA.cpp.

References children_, and ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::unbind().

Referenced by TAO_Regular_POA::remove_from_parent_i().

{
  int result = 0;

  // If we are not closing down, we must remove this child from our
  // collection.
  if (!this->cleanup_in_progress_)
    result = this->children_.unbind (child);

  // Otherwise, if we are closing down, we are currently iterating
  // over our children and there is not need to remove this child from
  // our collection.

  return result;
}

void TAO_Root_POA::destroy	(	CORBA::Boolean	etherealize_objects,
		CORBA::Boolean	wait_for_completion
	)

Definition at line 790 of file Root_POA.cpp.

References destroy_i().

{
  // Lock access for the duration of this transaction.
  TAO::Portable_Server::POA_Guard poa_guard (*this , 0);
  ACE_UNUSED_ARG (poa_guard);

  this->destroy_i (etherealize_objects, wait_for_completion);
}

void TAO_Root_POA::destroy_i	(	CORBA::Boolean	etherealize_objects,
		CORBA::Boolean	wait_for_completion
	)			[protected]

Definition at line 807 of file Root_POA.cpp.

References active_policy_strategies_, adapter_state_, adapter_state_changed(), check_for_valid_wait_for_completions(), children_, cleanup_in_progress_, complete_destruction_i(), deactivate_all_objects_i(), ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::end(), TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy(), TAO_Object_Adapter::non_servant_upcall_in_progress(), object_adapter(), ort_adapter_, ORT_adapter_factory(), ORT_adapter_i(), TAO::Portable_Server::Non_Servant_Upcall::poa(), poa_deactivated_hook(), remove_from_parent_i(), and waiting_destruction_.

Referenced by destroy().

{
  if (this->cleanup_in_progress_)
    return;

  // Is the <wait_for_completion> semantics for this thread correct?
  TAO_Root_POA::check_for_valid_wait_for_completions (this->orb_core (),
                                                      wait_for_completion);

  this->cleanup_in_progress_ = true;

  // Inform the custom servant dispatching strategy to stop the working
  // threads when the poa is destroyed.
  this->poa_deactivated_hook ();

  // This operation destroys the POA and all descendant POAs. The POA
  // so destroyed (that is, the POA with its name) may be re-created
  // later in the same process. (This differs from the
  // POAManager::deactivate operation that does not allow a
  // re-creation of its associated POA in the same process.)

  // Remove POA from the parent
  this->remove_from_parent_i ();

  TAO::ORT_Array array_obj_ref_template (1);

  CORBA::ULong i = 0;

  // Gather all ObjectReferenceTemplates and change all adapter states
  // to INACTIVE.
  for (CHILDREN::iterator iterator = this->children_.begin ();
       iterator != this->children_.end ();
       ++iterator)
    {
      TAO_Root_POA * const child_poa = (*iterator).int_id_;

      TAO::ORT_Adapter * const adapter = child_poa->ORT_adapter_i ();

      // In case no ORT library is linked we get zero.
      if (adapter != 0)
        {
          // Get the ObjectReferenceTemplate for the child POA.
          PortableInterceptor::ObjectReferenceTemplate * const ort =
            adapter->get_adapter_template ();

          // Add it to the sequence of object reference templates that
          // will be destroyed.
          array_obj_ref_template.size (1);

          array_obj_ref_template[0] = ort;
        }

      child_poa->adapter_state_ =
        PortableInterceptor::INACTIVE;

      // Notify the state changes to the IORInterceptors
      this->adapter_state_changed (array_obj_ref_template,
                                   PortableInterceptor::INACTIVE);

      if (adapter != 0)
        adapter->release (array_obj_ref_template[0]);

      ++i;
    }

  // Destroy all child POA's now.
  for (CHILDREN::iterator destroy_iterator = this->children_.begin ();
       destroy_iterator != this->children_.end ();
       ++destroy_iterator)
    {
      TAO_Root_POA *destroy_child_poa = (*destroy_iterator).int_id_;

      destroy_child_poa->destroy_i (etherealize_objects,
                                    wait_for_completion);
    }

  // Notify the lifespan strategy of our shutdown
  this->active_policy_strategies_.lifespan_strategy()->notify_shutdown ();

// @todo, is the exception handling above correct, should we just fail when
// the notify above fails

  // When a POA is destroyed, any requests that have started execution
  // continue to completion. Any requests that have not started
  // execution are processed as if they were newly arrived, that is,
  // the POA will attempt to cause recreation of the POA by invoking
  // one or more adapter activators as described in Section 3.3.3.
  // If the wait_for_completion parameter is TRUE, the destroy
  // operation will return only after all requests in process have
  // completed and all invocations of etherealize have
  // completed. Otherwise, the destroy operation returns after
  // destroying the POAs.

  this->deactivate_all_objects_i (etherealize_objects,
                                  wait_for_completion);

  // If there are no outstanding requests and that we are not in a
  // non-servant upcall or if we are in a non-servant upcall, make
  // sure we are the POA related to the non-servant upcall.
  TAO::Portable_Server::Non_Servant_Upcall *non_servant_upcall_in_progress =
    this->object_adapter ().non_servant_upcall_in_progress ();
  if (this->outstanding_requests_ == 0 &&
      (non_servant_upcall_in_progress == 0 ||
       &non_servant_upcall_in_progress->poa () != this))
    {
      TAO::ORT_Array my_array_obj_ref_template;

      TAO::ORT_Adapter * const ort_adapter =
        this->ORT_adapter_i ();

      // In case no ORT library is linked we get zero.
      if (ort_adapter != 0)
        {
          // Get the ObjectReferenceTemplate.
          PortableInterceptor::ObjectReferenceTemplate * const ort =
            ort_adapter->get_adapter_template ();

          // Add it to the sequence of object reference templates, we
          // just notify for ourselves that we are now non_existent,
          // our childs will do it for themselves.
          my_array_obj_ref_template.size (1);
          my_array_obj_ref_template[0] = ort;
        }

      // According to the ORT spec, after a POA is destroyed, its state
      // has to be changed to NON_EXISTENT and all the registered
      // interceptors are to be informed. Since, the POA is destroyed
      // and is released in the complete_destruction_i method, we are
      // trying to keep the poa still around by doing a duplicate of
      // it. (a hack).
      PortableServer::POA_var poa = PortableServer::POA::_duplicate (this);

      this->complete_destruction_i ();

      this->adapter_state_ = PortableInterceptor::NON_EXISTENT;

      this->adapter_state_changed (my_array_obj_ref_template,
                                   this->adapter_state_);

      if (ort_adapter != 0)
        {
          ort_adapter->release (my_array_obj_ref_template[0]);

          TAO::ORT_Adapter_Factory *ort_factory =
            this->ORT_adapter_factory ();

          ort_factory->destroy (ort_adapter);

          this->ort_adapter_ = 0;
        }
    }
  else
    {
      // Mark that we are ready for destruction.
      this->waiting_destruction_ = true;
    }
}

int TAO_Root_POA::enter

(

void

)

[protected]

Definition at line 2542 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::thread_strategy().

{
  return this->active_policy_strategies_.thread_strategy ()->enter();
}

void TAO_Root_POA::establish_components

(

void

)

[protected]

This method calls IORInterceptor::establish_components() method on all registered IORInterceptors, and IORInterceptor::components_established() once the former is completed.

Definition at line 2115 of file Root_POA.cpp.

References TAO_IORInterceptor_Adapter::establish_components(), TAO_ORB_Core::ior_interceptor_adapter(), and orb_core_.

Referenced by create_POA_i(), and TAO_Object_Adapter::open().

{
  TAO_IORInterceptor_Adapter *ior_adapter =
    this->orb_core_.ior_interceptor_adapter ();

  if (ior_adapter)
    {
      ior_adapter->establish_components (this);
    }
}

int TAO_Root_POA::exit

(

void

)

[protected]

Definition at line 2550 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::thread_strategy().

Referenced by TAO::Portable_Server::Servant_Upcall::single_threaded_poa_cleanup().

{
  return this->active_policy_strategies_.thread_strategy ()->exit();
}

PortableServer::POA_ptr TAO_Root_POA::find_POA	(	const char *	adapter_name,
		CORBA::Boolean	activate_it
	)

Definition at line 603 of file Root_POA.cpp.

References find_POA_i(), and TAO_POA_GUARD_RETURN.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  TAO_Root_POA *poa = this->find_POA_i (adapter_name, activate_it);

  return PortableServer::POA::_duplicate (poa);
}

TAO_Root_POA * TAO_Root_POA::find_POA_i	(	const ACE_CString &	child_name,
		CORBA::Boolean	activate_it
	)			[protected]

Definition at line 617 of file Root_POA.cpp.

References adapter_activator_, ACE_String_Base< CHAR >::c_str(), check_state(), children_, CORBA::COMPLETED_NO, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::find(), CORBA::is_nil(), and CORBA::OMGVMCID.

Referenced by TAO_Object_Adapter::activate_poa(), and find_POA().

{
  TAO_Root_POA *child = 0;
  int result = this->children_.find (child_name, child);

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)

  if (result != 0)
    {
      if (activate_it)
        {
          if (!CORBA::is_nil (this->adapter_activator_.in ()))
            {
              // Check our state
              this->check_state ();

              CORBA::Boolean success = false;
              try
                {
                  // ATTENTION: Trick locking here, see class header for details
                  TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (
                    *this);
                  ACE_UNUSED_ARG (non_servant_upcall);

                  // When unknown_adapter gives a system exception, the POA
                  // should raise OBJ_ADAPTER with standard minor code 1.
                  // See 11.3.9.2 of the Corba spec
                  success =
                    this->adapter_activator_->unknown_adapter (
                      this,
                      child_name.c_str ());
                }
              catch (const ::CORBA::SystemException&)
                {
                  throw ::CORBA::OBJ_ADAPTER (CORBA::OMGVMCID | 1,
                                              CORBA::COMPLETED_NO);
                }

              if (success)
                {
                  result = this->children_.find (child_name,
                                                 child);
                }
              else
                {
                  result = -1;
                }
            }
          else
            {
              result = -1;
            }
        }
      else
        {
          result = -1;
        }
    }
#else
  ACE_UNUSED_ARG (activate_it);
#endif /* TAO_HAS_MINIMUM_POA == 0 */

  if (result == 0)
    {
      return child;
    }
  else
    {
      // Otherwise, the AdapterNonExistent exception is raised.
      throw PortableServer::POA::AdapterNonExistent ();
    }
}

PortableServer::Servant TAO_Root_POA::find_servant	(	const PortableServer::ObjectId &	system_id,
		TAO::Portable_Server::Servant_Upcall &	servant_upcall,
		TAO::Portable_Server::POA_Current_Impl &	poa_current_impl
	)

Definition at line 2282 of file Root_POA.cpp.

References active_policy_strategies_, find_servant(), and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
          find_servant (system_id,
                        servant_upcall,
                        poa_current_impl);
}

PortableServer::Servant TAO_Root_POA::find_servant

(

const PortableServer::ObjectId &

system_id

)

Definition at line 1490 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by find_servant(), TAO::Portable_Server::RequestProcessingStrategyServantLocator::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyServantActivator::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyDefaultServant::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyAOMOnly::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyServantManager::system_id_to_servant(), TAO::Portable_Server::RequestProcessingStrategyDefaultServant::system_id_to_servant(), and TAO::Portable_Server::RequestProcessingStrategyAOMOnly::system_id_to_servant().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    find_servant (system_id);
}

int TAO_Root_POA::find_servant_priority	(	const PortableServer::ObjectId &	system_id,
		CORBA::Short &	priority
	)

Find the the servant with ObjectId <system_id>, and retrieve its priority.Usually used in RT CORBA with SERVER_DECLARED priority model.

Returns:

-1 if servant does not exist, else 0 indicating the servant exists and priority successfully retrieved.

Definition at line 2294 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
          find_servant_priority (system_id, priority);
}

ACE_INLINE const TAO_Object_Adapter::poa_name & TAO_Root_POA::folded_name

(

void

)

const

Definition at line 99 of file Root_POA.inl.

References folded_name_.

Referenced by TAO_Object_Adapter::Active_Hint_Strategy::find_persistent_poa(), and set_folded_name().

{
  return this->folded_name_;
}

ACE_INLINE PortableInterceptor::AdapterState TAO_Root_POA::get_adapter_state

(

void

)

Accessor methods to POA state.

The POA can be in one of HOLDING, ACTIVE, DISCARDING, INACTIVE and NON_EXISTENT states.

Definition at line 219 of file Root_POA.inl.

References adapter_state_.

{
  return this->adapter_state_;
}

ACE_INLINE PortableInterceptor::ObjectReferenceTemplate * TAO_Root_POA::get_adapter_template

(

void

)

[protected]

Accessor methods to ObjectReferenceTemplate.

Definition at line 38 of file Root_POA.inl.

References ORT_adapter(), and ort_adapter_.

{
  TAO::ORT_Adapter *adapter = this->ORT_adapter ();

  if (adapter)
    {
      return this->ort_adapter_->get_adapter_template();
    }

  return 0;
}

ACE_INLINE PortableInterceptor::ObjectReferenceTemplate * TAO_Root_POA::get_adapter_template_i

(

void

)

[protected]

Accessor methods to ObjectReferenceTemplate, non locked version.

Definition at line 51 of file Root_POA.inl.

{
  if (this->ORT_adapter_i ())
    {
      return this->ort_adapter_->get_adapter_template ();
    }

  return 0;
}

ACE_INLINE PortableInterceptor::ObjectReferenceFactory * TAO_Root_POA::get_obj_ref_factory

(

void

)

[protected]

Accessor methods to PortableInterceptor::ObjectReferenceFactory.

Definition at line 62 of file Root_POA.inl.

References ORT_adapter(), and ort_adapter_.

{
  TAO::ORT_Adapter *adapter = this->ORT_adapter ();

  if (adapter)
    {
      return this->ort_adapter_->get_obj_ref_factory();
    }

  return 0;
}

CORBA::Policy_ptr TAO_Root_POA::get_policy

(

CORBA::PolicyType

policy

)

Get the set policy of the given type.

Definition at line 2626 of file Root_POA.cpp.

References TAO_POA_Policy_Set::get_policy(), and policies_.

{
  return this->policies_.get_policy (policy);
}

PortableServer::Servant TAO_Root_POA::get_servant

(

void

)

Definition at line 2404 of file Root_POA.cpp.

References TAO_ServantBase::_add_ref(), get_servant_i(), and TAO_POA_GUARD_RETURN.

Referenced by get_servant_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  PortableServer::Servant servant = this->get_servant_i ();

  if (servant != 0)
    {
      // ATTENTION: Trick locking here, see class header for details
      TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*this);
      ACE_UNUSED_ARG (non_servant_upcall);

      // The POA invokes _add_ref once on the Servant before returning
      // it. If the application uses reference counting, the caller of
      // get_servant is responsible for invoking _remove_ref once on
      // the returned Servant when it is finished with it. A
      // conforming caller need not invoke _remove_ref on the returned
      // Servant if the type of the Servant uses the default reference
      // counting inherited from ServantBase.
      servant->_add_ref ();

      return servant;
    }
  else
    {
      // If no servant has been associated with the POA, the NoServant
      // exception is raised.
      throw PortableServer::POA::NoServant ();
    }
}

PortableServer::Servant TAO_Root_POA::get_servant_i

(

void

)

[protected]

Definition at line 2397 of file Root_POA.cpp.

References active_policy_strategies_, get_servant(), and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

Referenced by get_servant().

{
  return this->active_policy_strategies_.request_processing_strategy()->
    get_servant ();
}

PortableServer::ServantManager_ptr TAO_Root_POA::get_servant_manager

(

void

)

Definition at line 2377 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and TAO_POA_GUARD_RETURN.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (PortableServer::ServantManager::_nil ());

  return this->active_policy_strategies_.request_processing_strategy()->
    get_servant_manager ();
}

bool TAO_Root_POA::has_system_id

(

void

)

const

Definition at line 2457 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::id_assignment_strategy().

{
  return this->active_policy_strategies_.id_assignment_strategy ()->
    has_system_id ();
}

CORBA::OctetSeq * TAO_Root_POA::id

(

void

)

Definition at line 1555 of file Root_POA.cpp.

References ACE_NEW_THROW_EX.

{
  CORBA::OctetSeq *id = 0;
  ACE_NEW_THROW_EX (id,
                    CORBA::OctetSeq (this->id_),
                    CORBA::NO_MEMORY ());

  return id;
}

CORBA::Object_ptr TAO_Root_POA::id_to_reference

(

const PortableServer::ObjectId &

oid

)

Definition at line 766 of file Root_POA.cpp.

References id_to_reference_i(), and TAO_POA_GUARD_RETURN.

Referenced by TAO::Portable_Server::POA_Current_Impl::get_reference(), and id_to_reference_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->id_to_reference_i (oid, true);
}

CORBA::Object_ptr TAO_Root_POA::id_to_reference_i	(	const PortableServer::ObjectId &	oid,
		bool	indirect
	)

Definition at line 1547 of file Root_POA.cpp.

References active_policy_strategies_, id_to_reference(), and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by id_to_reference().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    id_to_reference (id, indirect);
}

PortableServer::Servant TAO_Root_POA::id_to_servant

(

const PortableServer::ObjectId &

oid

)

Definition at line 757 of file Root_POA.cpp.

References id_to_servant_i(), and TAO_POA_GUARD_RETURN.

Referenced by id_to_servant_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->id_to_servant_i (oid);
}

PortableServer::Servant TAO_Root_POA::id_to_servant_i

(

const PortableServer::ObjectId &

oid

)

[protected]

Definition at line 1513 of file Root_POA.cpp.

References TAO_ServantBase::_add_ref(), active_policy_strategies_, id_to_servant(), and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

Referenced by id_to_servant().

{

  PortableServer::Servant servant =
    this->active_policy_strategies_.request_processing_strategy()->
      id_to_servant (id);

  if (servant != 0)
    {
      // ATTENTION: Trick locking here, see class header for details
      TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*this);
      ACE_UNUSED_ARG (non_servant_upcall);

      // The POA invokes _add_ref once on the Servant before returning
      // it. If the application uses reference counting, the caller of
      // id_to_servant is responsible for invoking _remove_ref once on
      // the returned Servant when it is finished with it. A
      // conforming caller need not invoke _remove_ref on the returned
      // Servant if the type of the Servant uses the default reference
      // counting inherited from ServantBase.
      servant->_add_ref ();
    }

  return servant;
}

const char * TAO_Root_POA::imr_client_adapter_name

(

void

)

[static]

Gets the value of TAO_POA_Static_Resources::imr_client_adapter_name_.

Definition at line 2650 of file Root_POA.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_POA_Static_Resources::imr_client_adapter_name_, and TAO_POA_Static_Resources::instance().

Referenced by TAO::Portable_Server::LifespanStrategyPersistent::notify_shutdown(), and TAO::Portable_Server::LifespanStrategyPersistent::notify_startup().

{
  return TAO_POA_Static_Resources::instance ()->imr_client_adapter_name_.c_str();
}

void TAO_Root_POA::imr_client_adapter_name

(

const char *

name

)

[static]

Sets the value of TAO_POA_Static_Resources::imr_client_adapter_name_.

Definition at line 2644 of file Root_POA.cpp.

References TAO_POA_Static_Resources::imr_client_adapter_name_, and TAO_POA_Static_Resources::instance().

{
  TAO_POA_Static_Resources::instance ()->imr_client_adapter_name_ = name;
}

ACE_INLINE CORBA::ULong TAO_Root_POA::increment_outstanding_requests

(

void

)

[protected]

Definition at line 195 of file Root_POA.inl.

References outstanding_requests_.

Referenced by TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i().

{
  return ++this->outstanding_requests_;
}

CORBA::Object_ptr TAO_Root_POA::invoke_key_to_object

(

void

)

Definition at line 1927 of file Root_POA.cpp.

References TAO_Root_POA::Key_To_Object_Params::collocated_, create_object_key(), TAO_Root_POA::Key_To_Object_Params::indirect_, key_to_object(), key_to_object_params_, TAO_Root_POA::Key_To_Object_Params::priority_, TAO_Root_POA::Key_To_Object_Params::servant_, system_id(), TAO_Root_POA::Key_To_Object_Params::system_id_, and TAO_Root_POA::Key_To_Object_Params::type_id_.

Referenced by invoke_key_to_object_helper_i().

{
  PortableServer::ObjectId_var &system_id =
    *this->key_to_object_params_.system_id_;

  // Create object key.
  TAO::ObjectKey_var key =
    this->create_object_key (system_id.in ());

  return this->key_to_object (key.in (),
                              this->key_to_object_params_.type_id_,
                              this->key_to_object_params_.servant_,
                              this->key_to_object_params_.collocated_,
                              this->key_to_object_params_.priority_,
                              this->key_to_object_params_.indirect_);
}

CORBA::Object_ptr TAO_Root_POA::invoke_key_to_object_helper_i	(	const char *	repository_id,
		const PortableServer::ObjectId &	id
	)

Definition at line 1321 of file Root_POA.cpp.

References invoke_key_to_object().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::create_reference(), TAO::Portable_Server::ServantRetentionStrategyNonRetain::create_reference(), TAO::Portable_Server::ServantRetentionStrategyRetain::create_reference_with_id(), TAO::Portable_Server::ServantRetentionStrategyNonRetain::create_reference_with_id(), TAO::Portable_Server::ServantRetentionStrategyRetain::id_to_reference(), and TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_reference().

{
  const PortableInterceptor::ObjectId &user_oid =
    reinterpret_cast <const PortableInterceptor::ObjectId &>(id);

  // Ask the ORT to create the object.
  if (this->ORT_adapter_i ())
    {
      // Ask the ORT to create the object.
      return this->ort_adapter_->make_object (repository_id,
                                              user_oid);
    }
  else
    {
      return this->invoke_key_to_object ();
    }
}

CORBA::Boolean TAO_Root_POA::is_persistent

(

void

)

const

Definition at line 1292 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy().

Referenced by is_poa_generated(), parse_ir_object_key(), set_id(), and TAO::Portable_Server::ServantRetentionStrategyRetain::strategy_init().

{
  return active_policy_strategies_.lifespan_strategy()->is_persistent ();
}

bool TAO_Root_POA::is_poa_generated	(	CORBA::Object_ptr	reference,
		PortableServer::ObjectId &	system_id
	)

Definition at line 1424 of file Root_POA.cpp.

References CORBA::Object::_key(), is_persistent(), parse_key(), root(), system_id(), system_name(), and validate_lifespan().

Referenced by reference_to_id(), and reference_to_servant_i().

{
  TAO::ObjectKey_var key = reference->_key ();

  TAO_Object_Adapter::poa_name poa_system_name;
  CORBA::Boolean is_root = false;
  CORBA::Boolean is_persistent = false;
  CORBA::Boolean is_system_id = false;
  TAO::Portable_Server::Temporary_Creation_Time poa_creation_time;

  int const result = this->parse_key (key.in (),
                                      poa_system_name,
                                      system_id,
                                      is_root,
                                      is_persistent,
                                      is_system_id,
                                      poa_creation_time);
  if (result != 0 ||
      !this->root () &&
      poa_system_name != this->system_name () ||
      is_root != this->root () ||
      is_system_id != this->system_id () ||
      !this->validate_lifespan (is_persistent, poa_creation_time))
    {
      // The passed reference is NOT generated by this POA
      return false;
    }
  else
    {
      // The passed reference is generated by this POA
      return true;
    }
}

int TAO_Root_POA::is_poa_generated_id

(

const PortableServer::ObjectId &

id

)

Definition at line 1848 of file Root_POA.cpp.

References ACE_String_Base< CHAR >::length(), name_, and ACE_OS::strncmp().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::activate_object_with_id(), and create_reference_with_id_i().

{
#if defined (POA_NAME_IN_POA_GENERATED_ID)

  // Grab the buffer
  const char *id_buffer = (const char *) id.get_buffer ();

  // Check to see if the POA name is the first part of the id
  return
    this->name_.length () < id.length () &&
    ACE_OS::strncmp (id_buffer,
                     this->name_.c_str (),
                     this->name_.length ()) == 0;
#else /* POA_NAME_IN_POA_GENERATED_ID */

  ACE_UNUSED_ARG (id);
  return 1;

#endif /* POA_NAME_IN_POA_GENERATED_ID */
}

bool TAO_Root_POA::is_servant_activation_allowed	(	PortableServer::Servant	servant,
		bool &	wait_occurred_restart_call
	)

Definition at line 2449 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::id_uniqueness_strategy().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::activate_object(), TAO::Portable_Server::ServantRetentionStrategyRetain::activate_object_with_id(), and TAO::Portable_Server::RequestProcessingStrategyServantActivator::locate_servant().

{
  return this->active_policy_strategies_.id_uniqueness_strategy ()->
    is_servant_activation_allowed (servant, wait_occurred_restart_call);
}

int TAO_Root_POA::is_servant_active	(	PortableServer::Servant	servant,
		bool &	wait_occurred_restart_call
	)

Definition at line 2514 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by TAO::Portable_Server::IdUniquenessStrategyUnique::is_servant_activation_allowed().

{
  return this->active_policy_strategies_.servant_retention_strategy ()->
    is_servant_in_map (servant, wait_occurred_restart_call);
}

CORBA::Object_ptr TAO_Root_POA::key_to_object	(	const TAO::ObjectKey &	key,
		const char *	type_id,
		TAO_ServantBase *	servant,
		CORBA::Boolean	collocated,
		CORBA::Short	priority,
		bool	indirect
	)			[protected]

Wrapper for the ORB's key_to_object that will alter the object pointer if the ImplRepo is used.

Definition at line 1945 of file Root_POA.cpp.

References CORBA::Object::_nil(), ACE_DEBUG, ACE_ERROR, ACE_NEW_THROW_EX, ACE_TEXT_CHAR_TO_TCHAR, TAO_ORB_Core::check_shutdown(), TAO_ORB_Core::imr_endpoints_in_ior(), CORBA::Object::ior(), CORBA::is_nil(), key_to_stub_i(), LM_DEBUG, LM_ERROR, TAO_ORB_Core::orb(), orb_core(), orb_core_, TAO_Stub_Auto_Ptr::release(), TAO_Stub::servant_orb(), ACE_OS::strchr(), CORBA::ORB::string_to_object(), ACE_OS::strstr(), and TAO_debug_level.

Referenced by invoke_key_to_object().

{
  // Check if the ORB is still running, otherwise throw an exception.
  // @@ What if the ORB was destroyed?  In that case we shouldn't even
  //    get here!
  this->orb_core_.check_shutdown ();

  //
  // ImplRepo related.
  //
#if (TAO_HAS_MINIMUM_CORBA == 0)

  CORBA::Object_ptr obj = CORBA::Object::_nil ();

  if (indirect && this->active_policy_strategies_.lifespan_strategy()->use_imr ()
         && this->orb_core ().imr_endpoints_in_ior ())
    {
      // Check to see if we alter the IOR.
      CORBA::Object_var imr = this->orb_core ().implrepo_service ();

      if (CORBA::is_nil (imr.in ())
          || !imr->_stubobj ()
          || !imr->_stubobj ()->profile_in_use ())
        {
          if (TAO_debug_level > 1)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "Missing ImR IOR, will not use the ImR\n"));
            }
          goto orbkey;
        }

      CORBA::String_var imr_str =
        imr->_stubobj ()->profile_in_use ()->to_string ();

      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    "IMR IOR = \n%s\n",
                    ACE_TEXT_CHAR_TO_TCHAR (imr_str.in ())));

      // Search for "corbaloc:" alone, without the protocol.  This code
      // should be protocol neutral.
      const char corbaloc[] = "corbaloc:";
      char *pos = ACE_OS::strstr (imr_str.inout (), corbaloc);
      pos = ACE_OS::strchr (pos + sizeof (corbaloc), ':');

      pos = ACE_OS::strchr (pos + 1,
                            imr->_stubobj ()->profile_in_use ()->object_key_delimiter ());

      if (pos)
        pos[1] = 0;  // Crop the string.
      else
        {
          if (TAO_debug_level > 0)
            ACE_ERROR ((LM_ERROR,
                        "Could not parse ImR IOR, skipping ImRification\n"));
          goto orbkey;
        }

      ACE_CString ior (imr_str.in ());

      // Add the key.

      CORBA::String_var key_str;
      TAO::ObjectKey::encode_sequence_to_string (key_str.inout (), key);

      ior += key_str.in ();

      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    "ImR-ified IOR = \n%s\n",
                    ACE_TEXT_CHAR_TO_TCHAR (ior.c_str ())));

      obj = this->orb_core_.orb ()->string_to_object (ior.c_str ());

      return obj;
    }

orbkey:

#else
  ACE_UNUSED_ARG (indirect);
#endif /* TAO_HAS_MINIMUM_CORBA */

  TAO_Stub *data = this->key_to_stub_i (key, type_id, priority);

  TAO_Stub_Auto_Ptr safe_data (data);

  CORBA::Object_ptr tmp;

  if (this->orb_core_.optimize_collocation_objects ())
    {
      ACE_NEW_THROW_EX (tmp, CORBA::Object (data,
                                            collocated,
                                            servant),
                        CORBA::INTERNAL ());

    }
  else
    {
      ACE_NEW_THROW_EX (tmp,
                        CORBA::Object (data,
                                       collocated),
                        CORBA::INTERNAL ());
    }

  data->servant_orb (this->orb_core_.orb ());

  // Transfer ownership to the Object.
  (void) safe_data.release ();

  return tmp;
}

TAO_Stub * TAO_Root_POA::key_to_stub	(	const TAO::ObjectKey &	key,
		const char *	type_id,
		CORBA::Short	priority
	)

Create the correct stub, properly initialized with the attributes and policies attached to the current POA.

Definition at line 2065 of file Root_POA.cpp.

References TAO_ORB_Core::check_shutdown(), key_to_stub_i(), and orb_core_.

{
  // Check if the ORB is still running, otherwise throw an exception.
  // @@ What if the ORB was destroyed?  In that case we shouldn't even
  //    get here!
  this->orb_core_.check_shutdown ();

  return this->key_to_stub_i (key, type_id, priority);
}

TAO_Stub * TAO_Root_POA::key_to_stub_i	(	const TAO::ObjectKey &	key,
		const char *	type_id,
		CORBA::Short	priority
	)			[protected, virtual]

Like key_to_stub() but assume that the ORB is not shutting down.

Definition at line 2078 of file Root_POA.cpp.

References TAO_Thread_Lane_Resources::acceptor_registry(), ACE_NEW_RETURN, client_exposed_policies(), TAO_Acceptor_Filter_Factory::create_object(), create_stub_object(), filter_factory_, TAO_ORB_Core::lane_resources(), and orb_core_.

Referenced by key_to_object(), and key_to_stub().

{
  CORBA::PolicyList_var client_exposed_policies =
    this->client_exposed_policies (priority);

  TAO_Acceptor_Filter* filter = 0;

#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT) && !defined (CORBA_E_MICRO)
  if (this->filter_factory_)
    {
      filter = this->filter_factory_->create_object (this->poa_manager_);
    }
  else
#endif
    {
      ACE_NEW_RETURN (filter,
                      TAO_Default_Acceptor_Filter (),
                      0);
    }

  // Give ownership to the auto pointer.
  auto_ptr<TAO_Acceptor_Filter> new_filter (filter);

  TAO_Stub *data =
    this->create_stub_object (
      key,
      type_id,
      client_exposed_policies._retn (),
      filter,
      this->orb_core_.lane_resources ().acceptor_registry ());

  return data;
}

PortableServer::Servant TAO_Root_POA::locate_servant_i	(	const char *	operation,
		const PortableServer::ObjectId &	id,
		TAO::Portable_Server::Servant_Upcall &	servant_upcall,
		TAO::Portable_Server::POA_Current_Impl &	poa_current_impl,
		bool &	wait_occurred_restart_call
	)			[protected]

Definition at line 1566 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

{
  return this->active_policy_strategies_.request_processing_strategy()->
    locate_servant (operation,
                    system_id,
                    servant_upcall,
                    poa_current_impl,
                    wait_occurred_restart_call);
}

TAO_SERVANT_LOCATION TAO_Root_POA::locate_servant_i	(	const PortableServer::ObjectId &	id,
		PortableServer::Servant &	servant
	)			[protected]

Definition at line 2266 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

Referenced by TAO_Object_Adapter::find_servant_i(), TAO_Object_Adapter::locate_servant_i(), and TAO::Portable_Server::Servant_Upcall::prepare_for_upcall_i().

{
  return this->active_policy_strategies_.request_processing_strategy()->
          locate_servant (system_id, servant);
}

ACE_INLINE ACE_Lock & TAO_Root_POA::lock

(

void

)

Definition at line 14 of file Root_POA.inl.

References lock_.

Referenced by new_POA().

{
  return this->lock_;
}

ACE_INLINE const ACE_CString & TAO_Root_POA::name

(

void

)

const

Definition at line 87 of file Root_POA.inl.

References name_.

Referenced by TAO_Object_Adapter::activate_poa(), and new_POA().

{
  return this->name_;
}

ACE_INLINE char TAO_Root_POA::name_separator

(

void

)

[static]

Definition at line 111 of file Root_POA.inl.

Referenced by TAO_Object_Adapter::poa_name_iterator::operator++(), and set_folded_name().

{
  return '\0';
}

ACE_INLINE CORBA::ULong TAO_Root_POA::name_separator_length

(

void

)

[static]

Definition at line 117 of file Root_POA.inl.

Referenced by TAO_Object_Adapter::poa_name_iterator::operator *(), and set_folded_name().

{
  return sizeof (char);
}

TAO_Network_Priority_Hook * TAO_Root_POA::network_priority_hook

(

void

)

obtain a handle to the network priority hooks

Definition at line 2529 of file Root_POA.cpp.

References network_priority_hook_.

Referenced by TAO_Default_Servant_Dispatcher::pre_invoke_remote_request().

{
  return this->network_priority_hook_;
}

TAO_Root_POA * TAO_Root_POA::new_POA	(	const String &	name,
		PortableServer::POAManager_ptr	poa_manager,
		const TAO_POA_Policy_Set &	policies,
		TAO_Root_POA *	parent,
		ACE_Lock &	lock,
		TAO_SYNCH_MUTEX &	thread_lock,
		TAO_ORB_Core &	orb_core,
		TAO_Object_Adapter *	object_adapter
	)			[protected, virtual]

Template method for creating new POA's of this type.

Definition at line 501 of file Root_POA.cpp.

References ACE_NEW_THROW_EX, lock(), name(), object_adapter(), orb_core(), and policies().

Referenced by create_POA_i().

{
  TAO_Regular_POA *poa = 0;

  ACE_NEW_THROW_EX (poa,
                    TAO_Regular_POA (name,
                             poa_manager,
                             policies,
                             parent,
                             lock,
                             thread_lock,
                             orb_core,
                             object_adapter),
                    CORBA::NO_MEMORY ());

  return poa;
}

ACE_INLINE char TAO_Root_POA::non_root_key_char

(

void

)

[static, protected]

Definition at line 165 of file Root_POA.inl.

Referenced by parse_key(), TAO_Regular_POA::root_key_type(), and set_id().

{
  return 'N';
}

TAO_Object_Adapter & TAO_Root_POA::object_adapter

(

void

)

Definition at line 1921 of file Root_POA.cpp.

References object_adapter_.

Referenced by complete_destruction_i(), create_POA_i(), destroy_i(), TAO::Portable_Server::RequestProcessingStrategyServantLocator::locate_servant(), new_POA(), TAO::Portable_Server::POA_Guard::POA_Guard(), and TAO_Root_POA().

{
  return *this->object_adapter_;
}

ACE_INLINE TAO_ORB_Core & TAO_Root_POA::orb_core

(

void

)

const

ORB Core for POA.

Reimplemented from CORBA::Object.

Definition at line 213 of file Root_POA.inl.

References orb_core_.

Referenced by check_for_valid_wait_for_completions(), key_to_object(), new_POA(), TAO::Portable_Server::POA_Current_Impl::orb_core(), TAO::Portable_Server::ServantRetentionStrategyRetain::strategy_init(), and TAO::Portable_Server::LifespanStrategyPersistent::strategy_init().

{
  return this->orb_core_;
}

TAO::ORT_Adapter * TAO_Root_POA::ORT_adapter

(

void

)

[protected]

Get the ORT adapter, in case there is no adapter yet, this method will try to create one and hold the POA lock

Definition at line 2572 of file Root_POA.cpp.

References ort_adapter_, ORT_adapter_i(), and TAO_POA_GUARD_RETURN.

Referenced by get_adapter_template(), get_obj_ref_factory(), and set_obj_ref_factory().

{
  if (this->ort_adapter_ != 0)
    return this->ort_adapter_;

  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  // DCL ..
  if (this->ort_adapter_ != 0)
    {
      return this->ort_adapter_;
    }

  return this->ORT_adapter_i ();
}

TAO::ORT_Adapter_Factory * TAO_Root_POA::ORT_adapter_factory

(

void

)

[protected]

Definition at line 2303 of file Root_POA.cpp.

References TAO_ORB_Core::configuration(), ACE_Dynamic_Service< TYPE >::instance(), orb_core_, and ort_adapter_factory_name().

Referenced by complete_destruction_i(), destroy_i(), and ORT_adapter_i().

{
  return ACE_Dynamic_Service<TAO::ORT_Adapter_Factory>::instance
    (orb_core_.configuration (),
           TAO_Root_POA::ort_adapter_factory_name ());
}

const char * TAO_Root_POA::ort_adapter_factory_name

(

void

)

[static]

Definition at line 2638 of file Root_POA.cpp.

References ACE_String_Base< CHAR >::c_str(), TAO_POA_Static_Resources::instance(), and TAO_POA_Static_Resources::ort_adapter_factory_name_.

Referenced by ORT_adapter_factory().

{
  return TAO_POA_Static_Resources::instance ()->ort_adapter_factory_name_.c_str();
}

void TAO_Root_POA::ort_adapter_factory_name

(

const char *

name

)

[static]

Definition at line 2619 of file Root_POA.cpp.

References TAO_POA_Static_Resources::instance(), and TAO_POA_Static_Resources::ort_adapter_factory_name_.

{
  TAO_POA_Static_Resources::instance ()->ort_adapter_factory_name_ =
    name;
}

TAO::ORT_Adapter * TAO_Root_POA::ORT_adapter_i

(

void

)

[protected]

Get the ORT adapter, in case there is no adapter yet, this method will try to create one but assumes the POA lock is already hold

Definition at line 2311 of file Root_POA.cpp.

References adapter_name(), adapter_name_i(), orb_core_, TAO_ORB_Core::orbid(), ort_adapter_, and ORT_adapter_factory().

Referenced by complete_destruction_i(), destroy_i(), and ORT_adapter().

{
  if (this->ort_adapter_ != 0)
    return this->ort_adapter_;

  try
    {
      TAO::ORT_Adapter_Factory * ort_ap_factory = this->ORT_adapter_factory ();

      if (!ort_ap_factory)
        return 0;

      // Get the full adapter name of this POA, do this before we
      // create the adapter so that in case this fails, we just
      // return 0 and not a not activated adapter
      PortableInterceptor::AdapterName *adapter_name = this->adapter_name_i ();

      this->ort_adapter_ = ort_ap_factory->create ();

      if (!this->ort_adapter_)
        return 0;

      // @todo We have to look at this, we activate it but hold the POA lock,
      // in case we are called by ORT_adapter, we shouldn't keep the lock
      // here, but then the ort_adapter should be guarded against multiple
      // activations.
      this->ort_adapter_->activate (this->orb_core_.server_id (),
                                    this->orb_core_.orbid (),
                                    adapter_name,
                                    this);
    }
  catch (const ::CORBA::Exception& ex)
    {
      ex._tao_print_exception (
        "(%P|%t) Cannot initialize the "
        "object_reference_template_adapter\n");
    }

  return this->ort_adapter_;
}

ACE_INLINE void TAO_Root_POA::outstanding_requests

(

CORBA::ULong

new_outstanding_requests

)

[protected]

Definition at line 189 of file Root_POA.inl.

References outstanding_requests_.

{
  this->outstanding_requests_ = new_outstanding_requests;
}

ACE_INLINE CORBA::ULong TAO_Root_POA::outstanding_requests

(

void

)

const

Definition at line 183 of file Root_POA.inl.

References outstanding_requests_.

Referenced by TAO::Portable_Server::Non_Servant_Upcall::~Non_Servant_Upcall().

{
  return this->outstanding_requests_;
}

int TAO_Root_POA::parse_ir_object_key	(	const TAO::ObjectKey &	object_key,
		PortableServer::ObjectId &	user_id
	)			[static]

Calls protected static method used when POACurrent is not appropriate.

Definition at line 1902 of file Root_POA.cpp.

References is_persistent(), and parse_key().

{
  TAO_Object_Adapter::poa_name poa_system_name;
  CORBA::Boolean is_root = false;
  CORBA::Boolean is_persistent = false;
  CORBA::Boolean is_system_id = false;
  TAO::Portable_Server::Temporary_Creation_Time poa_creation_time;

  return TAO_Root_POA::parse_key (object_key,
                                  poa_system_name,
                                  user_id,
                                  is_root,
                                  is_persistent,
                                  is_system_id,
                                  poa_creation_time);
}

int TAO_Root_POA::parse_key	(	const TAO::ObjectKey &	key,
		TAO_Object_Adapter::poa_name &	poa_system_name,
		PortableServer::ObjectId &	system_id,
		CORBA::Boolean &	is_root,
		CORBA::Boolean &	is_persistent,
		CORBA::Boolean &	is_system_id,
		TAO::Portable_Server::Temporary_Creation_Time &	poa_creation_time
	)			[static, protected]

Definition at line 1582 of file Root_POA.cpp.

References ACE_NTOHL, TAO::Portable_Server::Temporary_Creation_Time::creation_time(), TAO::Portable_Server::Creation_Time::creation_time_length(), ACE_OS::memcpy(), non_root_key_char(), persistent_key_char(), persistent_key_type_length(), root_key_char(), root_key_type(), root_key_type_length(), system_id_key_char(), system_id_key_type_length(), TAO_Active_Object_Map::system_id_size(), TAO_OBJECTKEY_PREFIX_SIZE, transient_key_char(), TAO_Object_Adapter::transient_poa_name_size(), and user_id_key_char().

Referenced by is_poa_generated(), TAO_Object_Adapter::locate_poa(), and parse_ir_object_key().

{
  // Get the object key octets.
  const CORBA::Octet *key_data = key.get_buffer ();

  // Skip the object key prefix since we have already checked for this.
  CORBA::ULong starting_at = TAO_OBJECTKEY_PREFIX_SIZE;

  // Check the root indicator.
  char root_key_type = key_data[starting_at];
  if (root_key_type == TAO_Root_POA::root_key_char ())
    {
      is_root = true;
    }
  else if (root_key_type == TAO_Root_POA::non_root_key_char ())
    {
      is_root = false;
    }
  else
    {
      // Incorrect key
      return -1;
    }

  // Skip past the system id indicator
  starting_at += TAO_Root_POA::root_key_type_length ();

  // Check the system id indicator.
  char system_id_key_type = key_data[starting_at];
  if (system_id_key_type == TAO_Root_POA::system_id_key_char ())
    {
      is_system_id = true;
    }
  else if (system_id_key_type == TAO_Root_POA::user_id_key_char ())
    {
      is_system_id = false;
    }
  else
    {
      // Incorrect key
      return -1;
    }

  // Skip past the system id indicator
  starting_at += TAO_Root_POA::system_id_key_type_length ();

  // Check the persistence indicator
  char persistent_key_type = key_data[starting_at];
  if (persistent_key_type == TAO_Root_POA::persistent_key_char ())
    {
      is_persistent = true;
    }
  else if (persistent_key_type == TAO_Root_POA::transient_key_char ())
    {
      is_persistent = false;
    }
  else
    {
      // Incorrect key
      return -1;
    }

  // Skip past the persistent indicator
  starting_at += TAO_Root_POA::persistent_key_type_length ();

#if (POA_NO_TIMESTAMP == 0)
  // Grab the timestamp for transient POAs.
  if (!is_persistent)
    {
      // Take the creation time for the timestamp
      poa_creation_time.creation_time (key_data + starting_at);

      // Skip past the timestamp
      starting_at += TAO::Portable_Server::Creation_Time::creation_time_length ();
    }
#else
  ACE_UNUSED_ARG (poa_creation_time);
#endif /* POA_NO_TIMESTAMP */

  // Calculate the size of the POA name.
  CORBA::ULong poa_name_size = 0;
  if (!is_persistent)
    {
      // Transient POAs have fixed size.
      poa_name_size = TAO_Object_Adapter::transient_poa_name_size ();
    }
  else if (is_system_id)
    {
      // System ids have fixed size.
      poa_name_size = static_cast <CORBA::ULong>
                                  (key.length () - starting_at -
                                   TAO_Active_Object_Map::system_id_size ());
    }
  else
    {
      // Get the size from the object key.
      ACE_OS::memcpy (&poa_name_size,
                      key_data + starting_at,
                      sizeof (poa_name_size));
      poa_name_size = ACE_NTOHL (poa_name_size);

      starting_at += sizeof (poa_name_size);
    }

  // Grep the name if there is a name
  if (!is_root)
    {
      poa_system_name.replace (poa_name_size,
                               poa_name_size,
                               (CORBA::Octet *) key_data + starting_at,
                               0);

      starting_at += poa_name_size;
    }

  // The rest is the system id.
  CORBA::ULong system_id_size = key.length () - starting_at;

  // Reset <system_id>.
  system_id.length (system_id_size);
  CORBA::Octet * buf = system_id.get_buffer ();
  ACE_OS::memcpy (buf, key_data + starting_at, system_id_size);

  // Success
  return 0;
}

ACE_INLINE CORBA::Boolean TAO_Root_POA::persistent

(

void

)

[protected]

Definition at line 81 of file Root_POA.inl.

Referenced by TAO_Object_Adapter::bind_poa(), and TAO_Object_Adapter::unbind_poa().

{
  return (this->cached_policies_.lifespan () == PortableServer::PERSISTENT);
}

ACE_INLINE char TAO_Root_POA::persistent_key_char

(

void

)

[static, protected]

Definition at line 123 of file Root_POA.inl.

Referenced by parse_key().

{
  return 'P';
}

ACE_INLINE CORBA::ULong TAO_Root_POA::persistent_key_type_length

(

void

)

[static, protected]

Definition at line 135 of file Root_POA.inl.

Referenced by parse_key().

{
  return sizeof (char);
}

void TAO_Root_POA::poa_activated_hook

(

)

[virtual]

Hook - The POA has been (or is being) activated.

These hooks are needed by the CSD strategy to override and no-ops by default.

Definition at line 2711 of file Root_POA.cpp.

{
}

void TAO_Root_POA::poa_deactivated_hook

(

)

[virtual]

Hook - The POA has been deactivated.

Definition at line 2716 of file Root_POA.cpp.

Referenced by destroy_i().

{
}

ACE_INLINE TAO_POA_Policy_Set & TAO_Root_POA::policies

(

void

)

Accessor for POA policies.

Definition at line 20 of file Root_POA.inl.

References policies_.

Referenced by client_exposed_policies(), create_POA_i(), and new_POA().

{
  return this->policies_;
}

void TAO_Root_POA::post_invoke_servant_cleanup	(	const PortableServer::ObjectId &	system_id,
		const TAO::Portable_Server::Servant_Upcall &	servant_upcall
	)

Definition at line 2499 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy().

Referenced by TAO::Portable_Server::Servant_Upcall::post_invoke_servant_cleanup().

{
  this->active_policy_strategies_.request_processing_strategy ()->
    post_invoke_servant_cleanup (system_id, servant_upcall);
}

TAO::Portable_Server::Cached_Policies::PriorityModel TAO_Root_POA::priority_model

(

void

)

const

Definition at line 2535 of file Root_POA.cpp.

References cached_policies_, and TAO::Portable_Server::Cached_Policies::priority_model().

{
  return cached_policies_.priority_model ();
}

int TAO_Root_POA::rebind_using_user_id_and_system_id	(	PortableServer::Servant	servant,
		const PortableServer::ObjectId &	user_id,
		const PortableServer::ObjectId &	system_id,
		TAO::Portable_Server::Servant_Upcall &	servant_upcall
	)

Definition at line 2464 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

{
  return this->active_policy_strategies_.servant_retention_strategy ()->
    rebind_using_user_id_and_system_id (servant,
                                        user_id,
                                        system_id,
                                        servant_upcall);
}

PortableServer::ObjectId * TAO_Root_POA::reference_to_id

(

CORBA::Object_ptr

reference

)

Definition at line 1460 of file Root_POA.cpp.

References active_policy_strategies_, CORBA::is_nil(), is_poa_generated(), TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy(), system_id(), and TAO_POA_GUARD_RETURN.

{
  // Make sure that the reference is valid.
  if (CORBA::is_nil (reference))
    {
      throw ::CORBA::BAD_PARAM ();
    }

  // The WrongPolicy exception is declared to allow future extensions.

  // This operation is valid only if the reference was created by the
  // POA on which the operation is being performed.  If the object
  // reference was not created by this POA, the WrongAdapter exception
  // is raised.
  PortableServer::ObjectId system_id;
  bool const is_generated = this->is_poa_generated (reference, system_id);

  if (!is_generated)
    {
      throw PortableServer::POA::WrongAdapter ();
    }

  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->active_policy_strategies_.servant_retention_strategy()->
    system_id_to_object_id (system_id);
}

PortableServer::Servant TAO_Root_POA::reference_to_servant

(

CORBA::Object_ptr

reference

)

Definition at line 730 of file Root_POA.cpp.

References reference_to_servant_i(), and TAO_POA_GUARD_RETURN.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->reference_to_servant_i (reference);
}

PortableServer::Servant TAO_Root_POA::reference_to_servant_i

(

CORBA::Object_ptr

reference

)

[protected]

Definition at line 1381 of file Root_POA.cpp.

References TAO_ServantBase::_add_ref(), active_policy_strategies_, CORBA::is_nil(), is_poa_generated(), TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and system_id().

Referenced by reference_to_servant().

{
  // Make sure that the reference is valid.
  if (CORBA::is_nil (reference))
    {
      throw ::CORBA::BAD_PARAM ();
    }

  PortableServer::ObjectId system_id;
  bool const is_generated =
    this->is_poa_generated (reference, system_id);

  if (!is_generated)
    {
      // In case this object reference is not generated by this POA throw
      // an exception
      throw PortableServer::POA::WrongAdapter ();
    }

  PortableServer::Servant servant =
    this->active_policy_strategies_.request_processing_strategy()->
      system_id_to_servant (system_id);

  if (servant != 0)
    {
      // ATTENTION: Trick locking here, see class header for details
      TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*this);
      ACE_UNUSED_ARG (non_servant_upcall);

      // The POA invokes _add_ref once on the Servant before returning
      // it. If the application uses reference counting, the caller of
      // id_to_servant is responsible for invoking _remove_ref once on
      // the returned Servant when it is finished with it. A
      // conforming caller need not invoke _remove_ref on the returned
      // Servant if the type of the Servant uses the default reference
      // counting inherited from ServantBase.
      servant->_add_ref ();
    }

  return servant;
}

void TAO_Root_POA::remove_from_parent_i

(

void

)

[protected, virtual]

Reimplemented in TAO_Regular_POA.

Definition at line 801 of file Root_POA.cpp.

Referenced by destroy_i().

{
  // The root poa has no parent, so this is a noop
}

CORBA::Boolean TAO_Root_POA::root

(

void

)

const [protected, virtual]

Reimplemented in TAO_Regular_POA.

Definition at line 2566 of file Root_POA.cpp.

Referenced by is_poa_generated().

{
  return true;
}

ACE_INLINE char TAO_Root_POA::root_key_char

(

void

)

[static, protected]

Definition at line 159 of file Root_POA.inl.

Referenced by parse_key(), root_key_type(), and set_id().

{
  return 'R';
}

ACE_INLINE char TAO_Root_POA::root_key_type

(

void

)

[protected, virtual]

Reimplemented in TAO_Regular_POA.

Definition at line 171 of file Root_POA.inl.

References root_key_char().

Referenced by parse_key(), and TAO_Regular_POA::root_key_type().

{
  return TAO_Root_POA::root_key_char ();
}

ACE_INLINE CORBA::ULong TAO_Root_POA::root_key_type_length

(

void

)

[static, protected]

Definition at line 177 of file Root_POA.inl.

Referenced by parse_key(), and set_id().

{
  return sizeof (char);
}

void TAO_Root_POA::save_ior_component

(

const IOP::TaggedComponent &

component

)

Store the given TaggedComponent for eventual insertion into all object reference profiles.

Definition at line 2139 of file Root_POA.cpp.

References tagged_component_.

{
  CORBA::ULong const old_len = this->tagged_component_.length ();

  this->tagged_component_.length (old_len + 1);
  this->tagged_component_[old_len] = component;
}

void TAO_Root_POA::save_ior_component_and_profile_id	(	const IOP::TaggedComponent &	component,
		IOP::ProfileId	profile_id
	)

Store the given TaggedComponent for eventual insertion into all object reference profiles with the given ProfileId.

Definition at line 2149 of file Root_POA.cpp.

References profile_id_array_, ACE_Array_Base< T >::size(), and tagged_component_id_.

{
  // The length of this->tagged_component_id_ is the same as the
  // length of the profile_id_array_ since we are trying to make a
  // one-to-one link between these two arrays. So, whenever
  // this->tagged_component_id_ is increased, we need to increase the
  // size of this->profile_id_array_ also.

  CORBA::ULong const old_len = this->tagged_component_id_.length ();

  CORBA::ULong const new_len = old_len + 1;

  this->tagged_component_id_.length (new_len);
  this->tagged_component_id_[old_len] = component;

  this->profile_id_array_.size (new_len);
  this->profile_id_array_[old_len] = profile_id;
}

void TAO_Root_POA::servant_activated_hook	(	PortableServer::Servant	servant,
		const PortableServer::ObjectId &	oid
	)			[virtual]

Hook - A servant has been activated.

Definition at line 2721 of file Root_POA.cpp.

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::activate_object(), TAO::Portable_Server::ServantRetentionStrategyRetain::activate_object_with_id(), TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_system_id_i(), and TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_user_id().

{
}

void TAO_Root_POA::servant_deactivated_hook	(	PortableServer::Servant	servant,
		const PortableServer::ObjectId &	oid
	)			[virtual]

Hook - A servant has been deactivated.

Definition at line 2727 of file Root_POA.cpp.

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::deactivate_map_entry().

{
}

ACE_INLINE TAO_SYNCH_CONDITION & TAO_Root_POA::servant_deactivation_condition

(

void

)

Definition at line 231 of file Root_POA.inl.

References servant_deactivation_condition_.

{
  return servant_deactivation_condition_;
}

CORBA::Boolean TAO_Root_POA::servant_has_remaining_activations

(

PortableServer::Servant

servant

)

Definition at line 2478 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by TAO::Portable_Server::RequestProcessingStrategyServantActivator::etherealize_servant().

{
  return this->active_policy_strategies_.servant_retention_strategy ()->
    servant_has_remaining_activations (servant);
}

TAO_SERVANT_LOCATION TAO_Root_POA::servant_present	(	const PortableServer::ObjectId &	system_id,
		PortableServer::Servant &	servant
	)

Definition at line 2274 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by TAO::Portable_Server::RequestProcessingStrategyServantLocator::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyServantActivator::locate_servant(), TAO::Portable_Server::RequestProcessingStrategyDefaultServant::locate_servant(), and TAO::Portable_Server::RequestProcessingStrategyAOMOnly::locate_servant().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
          servant_present (system_id, servant);
}

PortableServer::ObjectId * TAO_Root_POA::servant_to_id

(

PortableServer::Servant

p_servant

)

Definition at line 712 of file Root_POA.cpp.

References servant_to_id_i(), and TAO_POA_GUARD_RETURN.

Referenced by servant_to_id_i().

{
  // If we had upgradeable locks, this would initially be a read lock
  //
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->servant_to_id_i (servant);
}

PortableServer::ObjectId * TAO_Root_POA::servant_to_id_i

(

PortableServer::Servant

servant

)

Definition at line 1367 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and servant_to_id().

Referenced by servant_to_id().

{
  return this->active_policy_strategies_.request_processing_strategy()->
    servant_to_id (servant);
}

CORBA::Object_ptr TAO_Root_POA::servant_to_reference

(

PortableServer::Servant

p_servant

)

Definition at line 739 of file Root_POA.cpp.

References CORBA::Object::_nil(), servant_to_reference_i(), and TAO_POA_GUARD_RETURN.

Referenced by servant_to_reference_i().

{
  TAO_POA_GUARD_RETURN (CORBA::Object::_nil ());

  return this->servant_to_reference_i (servant);
}

CORBA::Object_ptr TAO_Root_POA::servant_to_reference_i

(

PortableServer::Servant

p_servant

)

[protected]

Definition at line 1374 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy(), and servant_to_reference().

Referenced by servant_to_reference().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    servant_to_reference (servant);
}

PortableServer::ObjectId * TAO_Root_POA::servant_to_user_id

(

PortableServer::Servant

p_servant

)

Definition at line 723 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by TAO::Portable_Server::RequestProcessingStrategyServantManager::servant_to_id(), TAO::Portable_Server::RequestProcessingStrategyDefaultServant::servant_to_id(), and TAO::Portable_Server::RequestProcessingStrategyAOMOnly::servant_to_id().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    servant_to_user_id (servant);
}

CORBA::Short TAO_Root_POA::server_priority

(

void

)

const

Definition at line 2508 of file Root_POA.cpp.

References cached_policies_, and TAO::Portable_Server::Cached_Policies::server_priority().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_reference().

{
  return this->cached_policies_.server_priority ();
}

CORBA::Policy * TAO_Root_POA::server_protocol

(

void

)

[virtual]

Definition at line 2590 of file Root_POA.cpp.

{
  return 0;
}

void TAO_Root_POA::set_folded_name

(

TAO_Root_POA *

parent

)

[protected]

Definition at line 1870 of file Root_POA.cpp.

References folded_name(), folded_name_, ACE_String_Base< CHAR >::length(), ACE_OS::memcpy(), name_, name_separator(), and name_separator_length().

Referenced by TAO_Root_POA().

{
  size_t length = 0;
  size_t parent_length = 0;

  if (parent != 0)
    {
      parent_length = parent->folded_name ().length ();
      length += parent_length;
    }

  length += this->name_.length ();
  length += TAO_Root_POA::name_separator_length ();

  this->folded_name_.length (static_cast <CORBA::ULong> (length));
  CORBA::Octet *folded_name_buffer = this->folded_name_.get_buffer ();

  if (parent != 0)
    {
      ACE_OS::memcpy (folded_name_buffer,
                      parent->folded_name ().get_buffer (),
                      parent_length);
    }

  ACE_OS::memcpy (&folded_name_buffer[parent_length],
                  this->name_.c_str (),
                  this->name_.length ());

  folded_name_buffer[length - TAO_Root_POA::name_separator_length ()] = TAO_Root_POA::name_separator ();
}

void TAO_Root_POA::set_id

(

TAO_Root_POA *

parent

)

[protected]

Definition at line 1750 of file Root_POA.cpp.

References ACE_HTONL, active_policy_strategies_, id_, TAO::Portable_Server::Active_Policy_Strategies::id_assignment_strategy(), is_persistent(), TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy(), ACE_OS::memcpy(), non_root_key_char(), objectkey_prefix, root_key_char(), root_key_type_length(), system_id(), system_name_, and TAO_OBJECTKEY_PREFIX_SIZE.

Referenced by TAO_Root_POA().

{
  // Calculate the prefix size.
  CORBA::ULong prefix_size = 0;
  prefix_size += TAO_OBJECTKEY_PREFIX_SIZE;

  // If we are dealing with a persistent POA and user ids are being
  // used, then we need to add the POA name length field to the object
  // key. Otherwise, the POA name length can be calculated by looking
  // at the remainder after extracting other parts of the key.
  bool const add_poa_name_length =
    this->is_persistent () &&
    !this->system_id ();

  // Size required by the POA name.
  CORBA::ULong poa_name = 0;

  // Calculate the space required for the POA name.
  CORBA::ULong poa_name_length = this->system_name_->length ();
  if (parent != 0)
    {
      poa_name += poa_name_length;
    }

  // Check if we need to added the length of the POA name.
  if (add_poa_name_length)
    {
      poa_name += sizeof (poa_name_length);
    }

  // Get the space needed for the lifespan length
  // byte.
  CORBA::ULong const lifespan_key_length =
    this->active_policy_strategies_.lifespan_strategy()->key_length ();

  CORBA::ULong const id_assignment_key_length =
    this->active_policy_strategies_.id_assignment_strategy()->key_type_length ();

  // Calculate the space required for the POA id.
  CORBA::ULong const buffer_size =
    prefix_size +
    this->root_key_type_length () +
    id_assignment_key_length +
    lifespan_key_length +
    poa_name;

  // Create the buffer for the POA id.
  this->id_.length (buffer_size);
  CORBA::Octet *buffer = &this->id_[0];

  // Keeps track of where the next infomation goes; start at 0 byte.
  CORBA::ULong starting_at = 0;

  // Add the object key prefix.
  ACE_OS::memcpy (&buffer[starting_at],
                  &objectkey_prefix[0],
                  TAO_OBJECTKEY_PREFIX_SIZE);

  starting_at += TAO_OBJECTKEY_PREFIX_SIZE;

  // Copy the root byte.
  if (parent != 0)
    {
      buffer[starting_at] = (CORBA::Octet) TAO_Root_POA::non_root_key_char ();
    }
  else
    {
      buffer[starting_at] = (CORBA::Octet) TAO_Root_POA::root_key_char ();
    }
  starting_at += this->root_key_type_length ();

  // Add the id_assignment part
  this->active_policy_strategies_.id_assignment_strategy()->create_key (buffer, starting_at);

  // Add the lifespan part
  this->active_policy_strategies_.lifespan_strategy()->create_key (buffer, starting_at);

  // Check if we need to added the length of the POA name.
  if (add_poa_name_length)
    {
      poa_name_length = ACE_HTONL (poa_name_length);
      ACE_OS::memcpy (&buffer[starting_at],
                      &poa_name_length,
                      sizeof (poa_name_length));
      starting_at += sizeof (poa_name_length);
    }

  // Put the POA name into the key (for non-root POAs).
  if (parent != 0)
    {
      ACE_OS::memcpy (&buffer[starting_at],
                      this->system_name_->get_buffer (),
                      this->system_name_->length ());
      starting_at += this->system_name_->length ();
    }
}

void TAO_Root_POA::set_obj_ref_factory

(

PortableInterceptor::ObjectReferenceFactory *

current_factory

)

[protected]

Set the object reference factory.

Definition at line 174 of file Root_POA.cpp.

References ORT_adapter(), and ort_adapter_.

{
  TAO::ORT_Adapter *adapter = this->ORT_adapter ();

  if (adapter)
    {
      // Activate a different factory
      this->ort_adapter_->set_obj_ref_factory (current_factory);
    }
}

void TAO_Root_POA::set_servant

(

PortableServer::Servant

servant

)

Definition at line 2437 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and TAO_POA_GUARD.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD;

  this->active_policy_strategies_.request_processing_strategy()->
    set_servant (servant);
}

void TAO_Root_POA::set_servant_manager

(

PortableServer::ServantManager_ptr

imgr

)

Definition at line 2387 of file Root_POA.cpp.

References active_policy_strategies_, TAO::Portable_Server::Active_Policy_Strategies::request_processing_strategy(), and TAO_POA_GUARD.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD;

  this->active_policy_strategies_.request_processing_strategy()->
    set_servant_manager (imgr);
}

ACE_INLINE CORBA::Boolean TAO_Root_POA::system_id

(

void

)

Definition at line 75 of file Root_POA.inl.

Referenced by invoke_key_to_object(), is_poa_generated(), reference_to_id(), reference_to_servant_i(), set_id(), and TAO::Portable_Server::ServantRetentionStrategyRetain::strategy_init().

{
  return (this->cached_policies_.id_assignment () == PortableServer::SYSTEM_ID);
}

ACE_INLINE char TAO_Root_POA::system_id_key_char

(

void

)

[static, protected]

Definition at line 141 of file Root_POA.inl.

Referenced by parse_key().

{
  return 'S';
}

ACE_INLINE CORBA::ULong TAO_Root_POA::system_id_key_type_length

(

void

)

[static, protected]

Definition at line 153 of file Root_POA.inl.

Referenced by parse_key().

{
  return sizeof (char);
}

ACE_INLINE const TAO_Object_Adapter::poa_name & TAO_Root_POA::system_name

(

void

)

const

Definition at line 105 of file Root_POA.inl.

References system_name_.

Referenced by is_poa_generated().

{
  return this->system_name_.in ();
}

TAO_POA_Manager & TAO_Root_POA::tao_poa_manager

(

)

Return the POA Manager related to this POA.

Definition at line 693 of file Root_POA.cpp.

References poa_manager_.

Referenced by TAO::Portable_Server::LifespanStrategyTransient::check_state(), and TAO::Portable_Server::LifespanStrategyPersistent::check_state().

{
  return poa_manager_;
}

void TAO_Root_POA::the_activator

(

PortableServer::AdapterActivator_ptr

adapter_activator

)

Definition at line 2364 of file Root_POA.cpp.

References adapter_activator_, and TAO_POA_GUARD.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD;

  this->adapter_activator_ = PortableServer::AdapterActivator::_duplicate (adapter_activator);
}

PortableServer::AdapterActivator_ptr TAO_Root_POA::the_activator

(

void

)

Definition at line 2355 of file Root_POA.cpp.

References TAO_POA_GUARD_RETURN.

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (PortableServer::AdapterActivator::_nil ());

  return PortableServer::AdapterActivator::_duplicate (this->adapter_activator_.in ());
}

PortableServer::POAList * TAO_Root_POA::the_children

(

void

)

Definition at line 747 of file Root_POA.cpp.

References TAO_POA_GUARD_RETURN, and the_children_i().

{
  // Lock access for the duration of this transaction.
  TAO_POA_GUARD_RETURN (0);

  return this->the_children_i ();
}

PortableServer::POAList * TAO_Root_POA::the_children_i

(

void

)

[protected]

Definition at line 984 of file Root_POA.cpp.

References ACE_NEW_THROW_EX, children_, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::current_size(), and ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::end().

Referenced by the_children().

{
  PortableServer::POAList_var children;
  CORBA::ULong child_current = static_cast <CORBA::ULong>
                                           (this->children_.current_size ());
  ACE_NEW_THROW_EX (children,
                    PortableServer::POAList (child_current),
                    CORBA::NO_MEMORY ());

  children->length (child_current);

  CORBA::ULong index = 0;
  for (CHILDREN::iterator iterator = this->children_.begin ();
       iterator != this->children_.end ();
       ++iterator, ++index)
    {
      TAO_Root_POA *child_poa = (*iterator).int_id_;
      children[index] = PortableServer::POA::_duplicate (child_poa);
    }

  return children._retn ();
}

ACE_INLINE char * TAO_Root_POA::the_name

(

void

)

Definition at line 93 of file Root_POA.inl.

References CORBA::string_dup().

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::strategy_init().

{
  return CORBA::string_dup (this->name_.c_str ());
}

ACE_INLINE PortableServer::POA_ptr TAO_Root_POA::the_parent

(

void

)

Reimplemented in TAO_Regular_POA.

Definition at line 26 of file Root_POA.inl.

{
  return PortableServer::POA::_nil ();
}

PortableServer::POAManager_ptr TAO_Root_POA::the_POAManager

(

void

)

Definition at line 2656 of file Root_POA.cpp.

{
  return PortableServer::POAManager::_duplicate (&this->poa_manager_);
}

PortableServer::POAManagerFactory_ptr TAO_Root_POA::the_POAManagerFactory

(

void

)

Definition at line 2663 of file Root_POA.cpp.

{
  return PortableServer::POAManagerFactory::_duplicate (&this->poa_manager_factory_);
}

ACE_INLINE void * TAO_Root_POA::thread_pool

(

void

)

const [virtual]

Definition at line 225 of file Root_POA.inl.

{
  return 0;
}

ACE_INLINE char TAO_Root_POA::transient_key_char

(

void

)

[static, protected]

Definition at line 129 of file Root_POA.inl.

Referenced by parse_key().

{
  return 'T';
}

int TAO_Root_POA::unbind_using_user_id

(

const PortableServer::ObjectId &

user_id

)

Definition at line 1497 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    unbind_using_user_id  (user_id);
}

ACE_INLINE char TAO_Root_POA::user_id_key_char

(

void

)

[static, protected]

Definition at line 147 of file Root_POA.inl.

Referenced by parse_key().

{
  return 'U';
}

PortableServer::Servant TAO_Root_POA::user_id_to_servant_i

(

const PortableServer::ObjectId &

oid

)

Definition at line 1540 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

Referenced by TAO::Portable_Server::RequestProcessingStrategyServantManager::id_to_servant(), and TAO::Portable_Server::RequestProcessingStrategyAOMOnly::id_to_servant().

{
  return this->active_policy_strategies_.servant_retention_strategy()->
    user_id_to_servant (id);
}

bool TAO_Root_POA::validate_lifespan	(	CORBA::Boolean	is_persistent,
		const TAO::Portable_Server::Temporary_Creation_Time &	creation_time
	)			const

Definition at line 2557 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::lifespan_strategy().

Referenced by TAO_Object_Adapter::find_transient_poa(), and is_poa_generated().

{
  return this->active_policy_strategies_.lifespan_strategy()->
    validate (is_persistent, creation_time);
}

void TAO_Root_POA::wait_for_completions

(

CORBA::Boolean

wait_for_completion

)

[protected]

Definition at line 1211 of file Root_POA.cpp.

References outstanding_requests_.

Referenced by deactivate_all_objects_i().

{
  while (this->object_adapter ().enable_locking_ &&
         wait_for_completion &&
         this->outstanding_requests_ > 0)
    {
      this->wait_for_completion_pending_ = 1;

      int result = this->outstanding_requests_condition_.wait ();
      if (result == -1)
        {
          throw ::CORBA::OBJ_ADAPTER ();
        }
    }
}

ACE_INLINE CORBA::Boolean TAO_Root_POA::waiting_destruction

(

void

)

const

Definition at line 207 of file Root_POA.inl.

References waiting_destruction_.

{
  return this->waiting_destruction_;
}

CORBA::ULong TAO_Root_POA::waiting_servant_deactivation

(

void

)

const

Definition at line 2612 of file Root_POA.cpp.

References active_policy_strategies_, and TAO::Portable_Server::Active_Policy_Strategies::servant_retention_strategy().

{
  return this->active_policy_strategies_.servant_retention_strategy ()->
          waiting_servant_deactivation ();
}

---

Friends And Related Function Documentation

friend class TAO::Portable_Server::Non_Servant_Upcall [friend]

Definition at line 122 of file Root_POA.h.

friend class TAO::Portable_Server::Servant_Upcall [friend]

Definition at line 121 of file Root_POA.h.

friend class TAO_IORInfo [friend]

Definition at line 125 of file Root_POA.h.

friend class TAO_Object_Adapter [friend]

Definition at line 120 of file Root_POA.h.

friend class TAO_POA_Manager [friend]

Definition at line 123 of file Root_POA.h.

friend class TAO_RT_Collocation_Resolver [friend]

Definition at line 124 of file Root_POA.h.

---

Member Data Documentation

TAO::Portable_Server::Active_Policy_Strategies TAO_Root_POA::active_policy_strategies_ [protected]

Definition at line 723 of file Root_POA.h.

Referenced by activate_object_i(), activate_object_with_id_i(), allow_implicit_activation(), allow_multiple_activations(), check_state(), cleanup_servant(), complete_destruction_i(), create_reference_i(), create_reference_with_id_i(), deactivate_all_objects_i(), deactivate_object_i(), destroy_i(), enter(), exit(), find_servant(), find_servant_priority(), get_servant_i(), get_servant_manager(), has_system_id(), id_to_reference_i(), id_to_servant_i(), is_persistent(), is_servant_activation_allowed(), is_servant_active(), locate_servant_i(), post_invoke_servant_cleanup(), rebind_using_user_id_and_system_id(), reference_to_id(), reference_to_servant_i(), servant_has_remaining_activations(), servant_present(), servant_to_id_i(), servant_to_reference_i(), servant_to_user_id(), set_id(), set_servant(), set_servant_manager(), TAO_Root_POA(), unbind_using_user_id(), user_id_to_servant_i(), validate_lifespan(), and waiting_servant_deactivation().

PortableServer::AdapterActivator_var TAO_Root_POA::adapter_activator_ [protected]

Definition at line 726 of file Root_POA.h.

Referenced by complete_destruction_i(), find_POA_i(), and the_activator().

PortableInterceptor::AdapterState TAO_Root_POA::adapter_state_ [protected]

Adapter can be accepting, rejecting etc.

Definition at line 717 of file Root_POA.h.

Referenced by complete_destruction_i(), destroy_i(), and get_adapter_state().

TAO::Portable_Server::Cached_Policies TAO_Root_POA::cached_policies_ [protected]

Definition at line 719 of file Root_POA.h.

Referenced by cached_policies(), priority_model(), server_priority(), and TAO_Root_POA().

CORBA::ULong TAO_Root_POA::caller_key_to_object_

Definition at line 765 of file Root_POA.h.

CHILDREN TAO_Root_POA::children_ [protected]

Definition at line 738 of file Root_POA.h.

Referenced by delete_child(), destroy_i(), find_POA_i(), and the_children_i().

CORBA::Boolean TAO_Root_POA::cleanup_in_progress_ [protected]

Definition at line 747 of file Root_POA.h.

Referenced by cleanup_in_progress(), and destroy_i().

TAO_Acceptor_Filter_Factory* TAO_Root_POA::filter_factory_ [protected]

Definition at line 760 of file Root_POA.h.

Referenced by key_to_stub_i(), and TAO_Root_POA().

TAO_Object_Adapter::poa_name TAO_Root_POA::folded_name_ [protected]

Definition at line 707 of file Root_POA.h.

Referenced by folded_name(), and set_folded_name().

CORBA::OctetSeq TAO_Root_POA::id_ [protected]

Definition at line 711 of file Root_POA.h.

Referenced by create_object_key(), and set_id().

Key_To_Object_Params TAO_Root_POA::key_to_object_params_

Definition at line 786 of file Root_POA.h.

Referenced by TAO::Portable_Server::ServantRetentionStrategyRetain::create_reference(), TAO::Portable_Server::ServantRetentionStrategyNonRetain::create_reference(), TAO::Portable_Server::ServantRetentionStrategyRetain::create_reference_with_id(), TAO::Portable_Server::ServantRetentionStrategyNonRetain::create_reference_with_id(), TAO::Portable_Server::ServantRetentionStrategyRetain::id_to_reference(), invoke_key_to_object(), and TAO::Portable_Server::ServantRetentionStrategyRetain::servant_to_reference().

ACE_Lock& TAO_Root_POA::lock_ [protected]

Definition at line 740 of file Root_POA.h.

Referenced by lock().

String TAO_Root_POA::name_ [protected]

Definition at line 689 of file Root_POA.h.

Referenced by is_poa_generated_id(), name(), and set_folded_name().

TAO_Network_Priority_Hook* TAO_Root_POA::network_priority_hook_ [protected]

Definition at line 721 of file Root_POA.h.

Referenced by network_priority_hook(), and TAO_Root_POA().

TAO_Object_Adapter* TAO_Root_POA::object_adapter_ [protected]

The object adapter we belong to.

Definition at line 745 of file Root_POA.h.

Referenced by create_POA_i(), and object_adapter().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::Octet const TAO_Root_POA::objectkey_prefix [static]

Initial value:

 {
  024, 
  001, 
  017, 
  000
}

Definition at line 282 of file Root_POA.h.

Referenced by TAO_Object_Adapter::dispatch(), TAO_Object_Adapter::get_collocated_servant(), and set_id().

TAO_ORB_Core& TAO_Root_POA::orb_core_ [protected]

Reimplemented from CORBA::Object.

Definition at line 742 of file Root_POA.h.

Referenced by adapter_state_changed(), components_established(), create_POA_i(), create_stub_object(), establish_components(), key_to_object(), key_to_stub(), key_to_stub_i(), orb_core(), ORT_adapter_factory(), and ORT_adapter_i().

TAO::ORT_Adapter* TAO_Root_POA::ort_adapter_ [protected]

Pointer to the object reference template adapter.

Definition at line 714 of file Root_POA.h.

Referenced by complete_destruction_i(), destroy_i(), get_adapter_template(), get_obj_ref_factory(), ORT_adapter(), ORT_adapter_i(), and set_obj_ref_factory().

CORBA::ULong TAO_Root_POA::outstanding_requests_ [protected]

Definition at line 749 of file Root_POA.h.

Referenced by decrement_outstanding_requests(), increment_outstanding_requests(), outstanding_requests(), and wait_for_completions().

TAO_SYNCH_CONDITION TAO_Root_POA::outstanding_requests_condition_ [protected]

Definition at line 751 of file Root_POA.h.

Referenced by TAO::Portable_Server::Servant_Upcall::poa_cleanup().

TAO_POA_Manager& TAO_Root_POA::poa_manager_ [protected]

Reference to the POAManager that this poa assicuates with.

Definition at line 692 of file Root_POA.h.

Referenced by tao_poa_manager(), TAO_Root_POA(), and ~TAO_Root_POA().

TAO_POAManager_Factory& TAO_Root_POA::poa_manager_factory_ [protected]

Reference to the POAManagerFactory that generate the POAManager.

Definition at line 696 of file Root_POA.h.

TAO_POA_Policy_Set TAO_Root_POA::policies_ [protected]

Definition at line 705 of file Root_POA.h.

Referenced by client_exposed_policies(), get_policy(), and policies().

ACE_Array_Base<IOP::ProfileId> TAO_Root_POA::profile_id_array_ [protected]

Definition at line 703 of file Root_POA.h.

Referenced by save_ior_component_and_profile_id().

TAO_SYNCH_CONDITION TAO_Root_POA::servant_deactivation_condition_ [protected]

Definition at line 757 of file Root_POA.h.

Referenced by servant_deactivation_condition().

PortableServer::Servant TAO_Root_POA::servant_for_key_to_object_

Definition at line 767 of file Root_POA.h.

TAO_Object_Adapter::poa_name_var TAO_Root_POA::system_name_ [protected]

Definition at line 709 of file Root_POA.h.

Referenced by set_id(), and system_name().

IOP::TaggedComponentSeq TAO_Root_POA::tagged_component_ [protected]

Definition at line 699 of file Root_POA.h.

Referenced by create_stub_object(), and save_ior_component().

IOP::TaggedComponentSeq TAO_Root_POA::tagged_component_id_ [protected]

Definition at line 701 of file Root_POA.h.

Referenced by create_stub_object(), and save_ior_component_and_profile_id().

CORBA::Boolean TAO_Root_POA::wait_for_completion_pending_ [protected]

Definition at line 753 of file Root_POA.h.

CORBA::Boolean TAO_Root_POA::waiting_destruction_ [protected]

Definition at line 755 of file Root_POA.h.

Referenced by complete_destruction_i(), destroy_i(), and waiting_destruction().

---

The documentation for this class was generated from the following files:

• Root_POA.h
• Root_POA.cpp
• Root_POA.inl

---