TAO_Stub Class Reference

TAO_Stub. More...

#include <Stub.h>

Collaboration diagram for TAO_Stub:

[legend]List of all members.

Public Member Functions
virtual CORBA::Policy_ptr	get_policy (CORBA::PolicyType type)
virtual CORBA::Policy_ptr	get_cached_policy (TAO_Cached_Policy_Type type)
virtual TAO_Stub *	set_policy_overrides (const CORBA::PolicyList &policies, CORBA::SetOverrideType set_add)
virtual CORBA::PolicyList *	get_policy_overrides (const CORBA::PolicyTypeSeq &types)
TAO::Transport_Queueing_Strategy *	transport_queueing_strategy (void)
CORBA::ULong	hash (CORBA::ULong maximum)
CORBA::Boolean	is_equivalent (CORBA::Object_ptr other_obj)
	Implement the is_equivalent() method for the CORBA::Object.
	TAO_Stub (const char *repository_id, const TAO_MProfile &profiles, TAO_ORB_Core *orb_core)
	Construct from a repository ID and a list of profiles.
void	_incr_refcnt (void)
void	_decr_refcnt (void)
ACE_Lock *	profile_lock (void) const
TAO_Profile *	profile_in_use (void)
const TAO::ObjectKey &	object_key (void) const
	Return the ObjectKey.
TAO_MProfile *	make_profiles (void)
const TAO_MProfile &	base_profiles (void) const
	Obtain a reference to the basic profile set.
TAO_MProfile &	base_profiles (void)
	Obtain a reference to the basic profile set.
const TAO_MProfile *	forward_profiles (void) const
	Obtain a pointer to the forwarded profile set.
TAO_Profile *	next_profile (void)
	True if permanent location forward occured, in this case the lock must be set and the.
void	reset_profiles (void)
CORBA::Boolean	valid_forward_profile (void)
void	set_valid_profile (void)
	NON-THREAD-SAFE. Will set profile_success_ to 0.
CORBA::Boolean	valid_profile (void) const
TAO_Profile *	base_profiles (const TAO_MProfile &mprofiles)
void	add_forward_profiles (const TAO_MProfile &mprofiles, const CORBA::Boolean permanent_forward=false)
CORBA::Boolean	next_profile_retry (void)
TAO_ORB_Core *	orb_core (void) const
	Accessor.
CORBA::Boolean	is_collocated (void) const
	Is this stub collocated with the servant?
void	is_collocated (CORBA::Boolean)
	Mutator to mark this stub as being collocated with the servant.
CORBA::ORB_ptr	servant_orb_ptr (void)
	This returns a duplicated ORB pointer.
CORBA::ORB_var &	servant_orb_var (void)
	This returns the ORB var itself (generally for temporary use).
void	servant_orb (CORBA::ORB_ptr orb)
void	collocated_servant (TAO_Abstract_ServantBase *servant)
	Mutator for setting the servant in collocated cases.
TAO_Abstract_ServantBase *	collocated_servant (void) const
	Accessor for the servant reference in collocated cases.
void	object_proxy_broker (TAO::Object_Proxy_Broker *proxy_broker)
TAO::Object_Proxy_Broker *	object_proxy_broker (void) const
int	create_ior_info (IOP::IOR *&ior_info, CORBA::ULong &index)
void	destroy (void)
	Deallocate the TAO_Stub object.
CORBA::Boolean	optimize_collocation_objects (void) const
	Return the cached value from the ORB_Core.
CORBA::Boolean	marshal (TAO_OutputCDR &)
	Needed to avoid copying forward_profiles for thread safety.
Public Attributes
CORBA::String_var	type_id
	All objref representations carry around a type ID.
Protected Member Functions
virtual	~TAO_Stub (void)
void	reset_profiles_i (void)
	NON-THREAD SAFE version of reset_profiles (void);.
TAO_Profile *	next_profile_i (void)
	NON-THREAD SAFE version of next_profile (void).
Protected Attributes
TAO_ORB_Core_Auto_Ptr	orb_core_
	Automatically manage the ORB_Core reference count.
CORBA::ORB_var	orb_
CORBA::Boolean	is_collocated_
CORBA::ORB_var	servant_orb_
TAO_Abstract_ServantBase *	collocated_servant_
	Servant pointer. It is 0 except for collocated objects.
TAO::Object_Proxy_Broker *	object_proxy_broker_
	Pointer to the Proxy Broker.
TAO_MProfile	base_profiles_
	Ordered list of profiles for this object.
TAO_MProfile *	forward_profiles_
TAO_MProfile *	forward_profiles_perm_
TAO_Profile *	profile_in_use_
	This is the profile that we are currently sending/receiving with.
ACE_Lock *	profile_lock_ptr_
	Mutex to protect access to the forwarding profile.
CORBA::Boolean	profile_success_
	Have we successfully talked to the forward profile yet?
ACE_Atomic_Op< TAO_SYNCH_MUTEX, unsigned long >	refcount_
	Reference counter.
TAO_Policy_Set *	policies_
IOP::IOR *	ior_info_
IOP::IOR *	forwarded_ior_info_
	Forwarded IOR info.
const CORBA::Boolean	collocation_opt_
Private Member Functions
TAO_Profile *	set_profile_in_use_i (TAO_Profile *pfile)
void	reset_base ()
void	forward_back_one (void)
void	reset_forward ()
TAO_Profile *	next_forward_profile (void)
	NON-THREAD-SAFE. utility method for next_profile.
int	get_profile_ior_info (TAO_MProfile &profile, IOP::IOR *&ior_info)
	THREAD-SAFE Create the IOR info.
	TAO_Stub (const TAO_Stub &)
TAO_Stub &	operator= (const TAO_Stub &)

---

Detailed Description

TAO_Stub.

Per-objref data includes the (protocol-specific) Profile, which is handled by placing it into a subclass of this type along with data that may be used in protocol-specific caching schemes. The type ID (the data specified by CORBA 2.0 that gets exposed "on the wire", and in stringified objrefs) is held by this module. The stub APIs are member functions of this type.

Definition at line 69 of file Stub.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Stub::TAO_Stub (  const char *  repository_id, const TAO_MProfile &  profiles, TAO_ORB_Core *  orb_core )

Construct from a repository ID and a list of profiles. Definition at line 36 of file Stub.cpp. References CORBA::ORB::_duplicate(), ACE_DEBUG, ACE_TEXT, base_profiles(), TAO_ORB_Core_Auto_Ptr::get(), LM_DEBUG, profile_lock_ptr_, TAO_ORB_Core_Auto_Ptr::reset(), TAO_debug_level, TAO_HAS_CORBA_MESSAGING, TAO_ORB_Core_instance(), and the_tao_remote_object_proxy_broker(). : type_id (repository_id) , orb_core_ (orb_core) , orb_ () , is_collocated_ (false) , servant_orb_ () , collocated_servant_ (0) , object_proxy_broker_ (the_tao_remote_object_proxy_broker ()) , base_profiles_ ((CORBA::ULong) 0) , forward_profiles_ (0) , forward_profiles_perm_ (0) , profile_in_use_ (0) , profile_lock_ptr_ (0) , profile_success_ (false) , refcount_ (1) #if (TAO_HAS_CORBA_MESSAGING == 1) , policies_ (0) #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ , ior_info_ (0) , forwarded_ior_info_ (0) , collocation_opt_ (orb_core->optimize_collocation_objects ()) { if (this->orb_core_.get() == 0) { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO: (%P|%t) TAO_Stub created with default ") ACE_TEXT ("ORB core\n"))); } this->orb_core_.reset (TAO_ORB_Core_instance ()); } // Duplicate the ORB_Core, otherwise the allocators and other // resources that this class references (directly or indirectly) // could be destroyed before it is time. (void) this->orb_core_->_incr_refcnt (); // Cache the ORB pointer to respond faster to certain queries. this->orb_ = CORBA::ORB::_duplicate (this->orb_core_->orb ()); this->profile_lock_ptr_ = this->orb_core_->client_factory ()->create_profile_lock (); this->base_profiles (profiles); }

TAO_Stub::~TAO_Stub (  void   )  [protected, virtual]

Destructor is to be called only through _decr_refcnt() to enforce proper reference counting. Definition at line 86 of file Stub.cpp. References TAO_Profile::_decr_refcnt(), ACE_ASSERT, forward_profiles_, forwarded_ior_info_, ior_info_, policies_, profile_in_use_, profile_lock_ptr_, and reset_profiles(). { ACE_ASSERT (this->refcount_ == 0); if (this->forward_profiles_) reset_profiles (); if (this->profile_in_use_ != 0) { // decrease reference count on profile this->profile_in_use_->_decr_refcnt (); this->profile_in_use_ = 0; } delete this->profile_lock_ptr_; #if (TAO_HAS_CORBA_MESSAGING == 1) delete this->policies_; #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ if (this->ior_info_) delete this->ior_info_; if (this->forwarded_ior_info_) delete this->forwarded_ior_info_; }

TAO_Stub::TAO_Stub (  const TAO_Stub &   )  [private]

---

Member Function Documentation

void TAO_Stub::_decr_refcnt (  void   )

Definition at line 561 of file Stub.cpp. Referenced by TAO_Stub_Auto_Ptr::reset(), CORBA::Object::~Object(), and TAO_Stub_Auto_Ptr::~TAO_Stub_Auto_Ptr(). { if (--this->refcount_ == 0) delete this; }

void TAO_Stub::_incr_refcnt (  void   )

Definition at line 555 of file Stub.cpp. Referenced by TAO::Narrow_Utils< T >::unchecked_narrow(). { ++this->refcount_; }

void TAO_Stub::add_forward_profiles (  const TAO_MProfile &  mprofiles, const CORBA::Boolean  permanent_forward = false )

THREAD SAFE. Set the forward_profiles. This object will assume ownership of this TAO_MProfile object!! if permanent_forward is true, currently used profiles will be replaced permanently, otherwise stub may fallback to current profiles later. The flag permanent_forward=true is only valid if currently used profile set represents a GroupObject (IOGR), otherwise this flag will be ignored. Definition at line 116 of file Stub.cpp. References ACE_GUARD, ACE_NEW, base_profiles_, forward_profiles_, forward_profiles_perm_, TAO_Profile::forward_to(), profile_in_use_, profile_success_, and reset_forward(). Referenced by TAO::LocateRequest_Invocation_Adapter::object_forwarded(), and TAO::Invocation_Adapter::object_forwarded(). { // we assume that the profile_in_use_ is being // forwarded! Grab the lock so things don't change. ACE_MT (ACE_GUARD (ACE_Lock, guard, *this->profile_lock_ptr_)); if (permanent_forward) { // paranoid, reset the bookmark, then clear the forward-stack this->forward_profiles_perm_ = 0; this->reset_forward (); } TAO_MProfile *now_pfiles = this->forward_profiles_; if (now_pfiles == 0) now_pfiles = &this->base_profiles_; ACE_NEW (this->forward_profiles_, TAO_MProfile (mprofiles)); if (permanent_forward) // bookmark the new element at bottom of stack this->forward_profiles_perm_ = this->forward_profiles_; // forwarded profile points to the new IOR (profiles) this->profile_in_use_->forward_to (this->forward_profiles_); // new profile list points back to the list which was forwarded. this->forward_profiles_->forward_from (now_pfiles); // make sure we start at the beginning of mprofiles this->forward_profiles_->rewind (); // Since we have been forwarded, we must set profile_success_ to false // since we are starting a new with a new set of profiles! this->profile_success_ = false; }

ACE_INLINE TAO_Profile * TAO_Stub::base_profiles (  const TAO_MProfile &  mprofiles  )

Initialize the base_profiles_ and set profile_in_use_ to reference the first profile. Definition at line 172 of file Stub.inl. References ACE_GUARD_RETURN, base_profiles_, profile_in_use_, reset_base(), reset_forward(), and TAO_MProfile::set(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->profile_lock_ptr_, 0)); // first reset things so we start from scratch! // @note This reset forward could effect the collocation status // but as this method is only used from the Stub ctr, when the status // is already correctly set, we don't reinitialise here. sm. this->reset_forward (); this->base_profiles_.set (mprofiles); this->reset_base (); return this->profile_in_use_; }

ACE_INLINE TAO_MProfile & TAO_Stub::base_profiles (  void   )

Obtain a reference to the basic profile set. Definition at line 224 of file Stub.inl. References base_profiles_. { return this->base_profiles_; }

ACE_INLINE const TAO_MProfile & TAO_Stub::base_profiles (  void   )  const

Obtain a reference to the basic profile set. Definition at line 218 of file Stub.inl. References base_profiles_. Referenced by TAO_ORB_Core::create_object(), TAO_ORB_Core::create_stub_object(), TAO_ORB_Core::initialize_object(), TAO::LocateRequest_Invocation_Adapter::object_forwarded(), TAO::Invocation_Adapter::object_forwarded(), CORBA::ORB::object_to_string(), TAO_ORB_Core::reinitialize_object(), and TAO_Stub(). { return this->base_profiles_; }

ACE_INLINE TAO_Abstract_ServantBase * TAO_Stub::collocated_servant (  void   )  const

Accessor for the servant reference in collocated cases. Definition at line 268 of file Stub.inl. References collocated_servant_. { return collocated_servant_; }

ACE_INLINE void TAO_Stub::collocated_servant (  TAO_Abstract_ServantBase *  servant  )

Mutator for setting the servant in collocated cases. Definition at line 274 of file Stub.inl. References collocated_servant_. Referenced by CORBA::Object::_servant(), TAO_Adapter_Registry::create_collocated_object(), CORBA::Object::Object(), and CORBA::Object::set_collocated_servant(). { this->collocated_servant_ = servant; }

int TAO_Stub::create_ior_info (  IOP::IOR *&  ior_info, CORBA::ULong &  index )

Create the IOP::IOR info. We will create the info at most once. Get the index of the profile we are using to make the invocation. Definition at line 159 of file Stub.cpp. References ACE_GUARD_RETURN, base_profiles_, forward_profiles_, forwarded_ior_info_, TAO_MProfile::get_profile(), get_profile_ior_info(), ior_info_, TAO_MProfile::profile_count(), and profile_in_use_. Referenced by TAO::Remote_Invocation::init_target_spec(). { // We are creating the IOR info. Let us not be disturbed. So grab a // lock. ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->profile_lock_ptr_, -1)); IOP::IOR *tmp_info = 0; if (this->forward_profiles_ != 0) { if (this->forwarded_ior_info_ == 0) { this->get_profile_ior_info (*this->forward_profiles_, tmp_info); this->forwarded_ior_info_ = tmp_info; } // First we look at the forward profiles to see whether the // profile_in_use is any of it. for (CORBA::ULong i = 0; i < this->forward_profiles_->profile_count (); ++i) { if (this->forward_profiles_->get_profile (i) == this->profile_in_use_) { ior_info = this->forwarded_ior_info_; index = i; return 0; } } } // Else we look at the base profiles if (this->ior_info_ == 0) { this->get_profile_ior_info (this->base_profiles_, tmp_info); this->ior_info_ = tmp_info; } for (CORBA::ULong ind = 0; ind < this->base_profiles_.profile_count (); ++ind) { if (this->base_profiles_.get_profile (ind) == this->profile_in_use_) { index = ind; ior_info = this->ior_info_; return 0; } } // Error, there was no match return -1; }

ACE_INLINE void TAO_Stub::destroy (  void   )

Deallocate the TAO_Stub object. This method is intended to be used only by the CORBA::Object class. Definition at line 292 of file Stub.inl. { // The reference count better be zero at this point! delete this; }

void TAO_Stub::forward_back_one (  void   )  [private]

NON-THREAD-SAFE. Utility method which unrolls (removes or pops) the top most forwarding profile list. Definition at line 349 of file Stub.cpp. References base_profiles_, TAO_MProfile::forward_from(), forward_profiles_, TAO_Profile::forward_to(), and TAO_MProfile::get_current_profile(). Referenced by next_forward_profile(), and reset_forward(). { TAO_MProfile *from = forward_profiles_->forward_from (); delete this->forward_profiles_; // the current profile in this profile list is no // longer being forwarded, so set the reference to zero. if (from == &this->base_profiles_) { this->base_profiles_.get_current_profile ()->forward_to (0); this->forward_profiles_ = 0; } else { from->get_current_profile ()->forward_to (0); this->forward_profiles_ = from; } }

ACE_INLINE const TAO_MProfile * TAO_Stub::forward_profiles (  void   )  const

Obtain a pointer to the forwarded profile set. Definition at line 230 of file Stub.inl. References forward_profiles_. Referenced by TAO_ORB_Core::reinitialize_object(). { return this->forward_profiles_; }

CORBA::Policy_ptr TAO_Stub::get_cached_policy (  TAO_Cached_Policy_Type  type  )  [virtual]

Definition at line 420 of file Stub.cpp. References TAO_Objref_Var_T< T >::_retn(), TAO_Policy_Set::get_cached_policy(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policies_, and CORBA::Policy_var. Referenced by CORBA::Object::_get_cached_policy(). { // No need to lock, the stub only changes its policies at // construction time... CORBA::Policy_var result; if (this->policies_ != 0) { result = this->policies_->get_cached_policy (type); } if (CORBA::is_nil (result.in ())) { result = this->orb_core_->get_cached_policy_including_current (type); } return result._retn (); }

CORBA::Policy_ptr TAO_Stub::get_policy (  CORBA::PolicyType  type  )  [virtual]

Returns the effective policy if type is a known client-exposed policy type. Returns the effective override for all other policy types. Definition at line 400 of file Stub.cpp. References TAO_Objref_Var_T< T >::_retn(), TAO_Policy_Set::get_policy(), TAO_Objref_Var_T< T >::in(), CORBA::is_nil(), policies_, CORBA::Policy_var, and CORBA::PolicyType. Referenced by CORBA::Object::_get_policy(). { // No need to lock, the stub only changes its policies at // construction time... CORBA::Policy_var result; if (this->policies_ != 0) { result = this->policies_->get_policy (type); } if (CORBA::is_nil (result.in ())) { result = this->orb_core_->get_policy_including_current (type); } return result._retn (); }

CORBA::PolicyList * TAO_Stub::get_policy_overrides (  const CORBA::PolicyTypeSeq &  types  )  [virtual]

Definition at line 474 of file Stub.cpp. References ACE_NEW_THROW_EX, TAO_Policy_Set::get_policy_overrides(), policies_, CORBA::PolicyList, and CORBA::PolicyTypeSeq. Referenced by CORBA::Object::_get_policy_overrides(). { if (this->policies_ == 0) { CORBA::PolicyList *policy_list_ptr = 0; ACE_NEW_THROW_EX (policy_list_ptr, CORBA::PolicyList (), CORBA::NO_MEMORY ()); return policy_list_ptr; } else { return this->policies_->get_policy_overrides (types); } }

int TAO_Stub::get_profile_ior_info (  TAO_MProfile &  profile, IOP::IOR *&  ior_info )  [private]

THREAD-SAFE Create the IOR info. Definition at line 241 of file Stub.cpp. References ACE_NEW_THROW_EX, TAO_Profile::create_tagged_profile(), TAO_MProfile::get_profile(), TAO_MProfile::profile_count(), and IOP::IOR::profiles. Referenced by create_ior_info(). { ACE_NEW_THROW_EX (ior_info, IOP::IOR (), CORBA::NO_MEMORY ()); // Get the number of elements CORBA::ULong const count = profiles.profile_count (); // Set the number of elements in the sequence of tagged_profile ior_info->profiles.length (count); // Call the create_tagged_profile one every member of the // profile and make the sequence for (CORBA::ULong index = 0; index < count; ++index) { TAO_Profile *prof = profiles.get_profile (index); IOP::TaggedProfile *tp = prof->create_tagged_profile (); if (tp == 0) throw ::CORBA::NO_MEMORY (); ior_info->profiles[index] = *tp; } return 0; }

CORBA::ULong TAO_Stub::hash (  CORBA::ULong  maximum  )

All objref representations know how to hash themselves and compare themselves for equivalence to others. It's easily possible to have two objrefs that are distinct copies of data that refers/points to the same remote object (i.e. are equivalent). Definition at line 294 of file Stub.cpp. References base_profiles_, and TAO_MProfile::hash(). Referenced by CORBA::Object::_hash(). { // we rely on the profile objects that its address info return this->base_profiles_.hash (max); }

void TAO_Stub::is_collocated (  CORBA::Boolean   )

Mutator to mark this stub as being collocated with the servant. Definition at line 270 of file Stub.cpp. References _TAO_Object_Proxy_Broker_Factory_function_pointer, is_collocated_, object_proxy_broker_, and the_tao_remote_object_proxy_broker(). { if (this->is_collocated_ != collocated) { if (collocated && _TAO_Object_Proxy_Broker_Factory_function_pointer != 0) { this->object_proxy_broker_ = _TAO_Object_Proxy_Broker_Factory_function_pointer (); } else { this->object_proxy_broker_ = the_tao_remote_object_proxy_broker (); } this->is_collocated_ = collocated; } }

ACE_INLINE CORBA::Boolean TAO_Stub::is_collocated (  void   )  const

Is this stub collocated with the servant? Definition at line 236 of file Stub.inl. References is_collocated_. Referenced by CORBA::Object::_is_collocated(), CORBA::Object::Object(), and CORBA::Object::set_collocated_servant(). { return this->is_collocated_; }

CORBA::Boolean TAO_Stub::is_equivalent (  CORBA::Object_ptr  other_obj  )

Implement the is_equivalent() method for the CORBA::Object. Definition at line 309 of file Stub.cpp. References CORBA::Object::_stubobj(), TAO_Profile::is_equivalent(), CORBA::is_nil(), CORBA::Object_ptr, and profile_in_use_. Referenced by CORBA::Object::_is_equivalent(). { if (CORBA::is_nil (other_obj)) return false; TAO_Profile * const other_profile = other_obj->_stubobj ()->profile_in_use_; TAO_Profile * const this_profile = this->profile_in_use_; if (other_profile == 0 || this_profile == 0) return false; // Compare the profiles return this_profile->is_equivalent (other_profile); }

ACE_INLINE TAO_MProfile * TAO_Stub::make_profiles (  void   )

Copy of the profile list, user must free memory when done. although the user can call make_profiles() then reorder the list and give it back to TAO_Stub. Definition at line 55 of file Stub.inl. References ACE_NEW_RETURN, and base_profiles_. { TAO_MProfile *mp = 0; ACE_NEW_RETURN (mp, TAO_MProfile (base_profiles_), 0); return mp; }

CORBA::Boolean TAO_Stub::marshal (  TAO_OutputCDR &   )

Needed to avoid copying forward_profiles for thread safety. Definition at line 494 of file Stub.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, base_profiles_, TAO_Profile::encode(), forward_profiles_perm_, TAO_MProfile::get_profile(), ACE_OutputCDR::good_bit(), TAO::String_var< charT >::in(), and TAO_MProfile::profile_count(). Referenced by operator<<(). { // do as many outside of locked else-branch as posssible // STRING, a type ID hint if ((cdr << this->type_id.in()) == 0) return 0; if ( ! this->forward_profiles_perm_) { const TAO_MProfile& mprofile = this->base_profiles_; CORBA::ULong const profile_count = mprofile.profile_count (); if ((cdr << profile_count) == 0) return 0; // @@ The MProfile should be locked during this iteration, is there // anyway to achieve that? for (CORBA::ULong i = 0; i < profile_count; ++i) { const TAO_Profile* p = mprofile.get_profile (i); if (p->encode (cdr) == 0) return 0; } } else { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->profile_lock_ptr_, 0)); ACE_ASSERT(this->forward_profiles_ !=0); // paranoid - in case of FT the basic_profiles_ would do, too, // but might be dated const TAO_MProfile& mprofile = this->forward_profiles_perm_ ? *(this->forward_profiles_perm_) : this->base_profiles_; CORBA::ULong const profile_count = mprofile.profile_count (); if ((cdr << profile_count) == 0) return 0; // @@ The MProfile should be locked during this iteration, is there // anyway to achieve that? for (CORBA::ULong i = 0; i < profile_count; ++i) { const TAO_Profile* p = mprofile.get_profile (i); if (p->encode (cdr) == 0) return 0; } // release ACE_Lock } return (CORBA::Boolean) cdr.good_bit (); }

ACE_INLINE TAO_Profile * TAO_Stub::next_forward_profile (  void   )  [private]

NON-THREAD-SAFE. utility method for next_profile. Definition at line 67 of file Stub.inl. References forward_back_one(), forward_profiles_, forward_profiles_perm_, and TAO_MProfile::get_next(). Referenced by next_profile_i(). { TAO_Profile *pfile_next = 0; while (this->forward_profiles_ && (pfile_next = this->forward_profiles_->get_next ()) == 0 && this->forward_profiles_ != this->forward_profiles_perm_) // do not remove permanent forward from bottom of stack // that was the last profile. Now we clean up our forward profiles. // since we own the forward MProfiles, we must delete them when done. this->forward_back_one (); return pfile_next; }

ACE_INLINE TAO_Profile * TAO_Stub::next_profile (  void   )

True if permanent location forward occured, in this case the lock must be set and the. THREAD SAFE. If forward_profiles is null then this will get the next profile in the base_profiles list. If forward is not null then this will get the next profile for the list of forwarding profiles. If all profiles have been tried then 0 is returned and profile_in_use_ is set to the first profile in the base_profiles list. Definition at line 143 of file Stub.inl. References ACE_GUARD_RETURN, and next_profile_i(). Referenced by TAO::LocateRequest_Invocation_Adapter::object_forwarded(), and TAO::Invocation_Adapter::object_forwarded(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->profile_lock_ptr_, 0)); return this->next_profile_i (); }

ACE_INLINE TAO_Profile * TAO_Stub::next_profile_i (  void   )  [protected]

NON-THREAD SAFE version of next_profile (void). Definition at line 82 of file Stub.inl. References base_profiles_, forward_profiles_, forward_profiles_perm_, TAO_MProfile::get_next(), next_forward_profile(), profile_success_, reset_base(), TAO_MProfile::rewind(), and set_profile_in_use_i(). Referenced by next_profile(), and next_profile_retry(). { TAO_Profile *pfile_next = 0; // First handle the case that a permanent forward occured if (this->forward_profiles_perm_) // the permanent forward defined // at bottom of stack // forward_profiles_ { // In case of permanent forward the base_profiles are ingored. pfile_next = this->next_forward_profile (); if (pfile_next == 0) { // COND: this->forward_profiles_ == this->forward_profiles_perm_ // reached end of list of permanent forward profiles // now, reset forward_profiles_perm_ this->forward_profiles_->rewind (); this->profile_success_ = false; this->set_profile_in_use_i (this->forward_profiles_->get_next()); } else this->set_profile_in_use_i (pfile_next); // We may have been forwarded to / from a collocated situation // Check for this and apply / remove optimisation if required. this->orb_core_->reinitialize_object (this); return pfile_next; } else { if (this->forward_profiles_) // Now do the common operation { pfile_next = this->next_forward_profile (); if (pfile_next == 0) { // Fall back to base profiles pfile_next = this->base_profiles_.get_next (); } // We may have been forwarded to / from a collocated situation // Check for this and apply / remove optimisation if required. this->orb_core_->reinitialize_object (this); } else pfile_next = this->base_profiles_.get_next (); if (pfile_next == 0) this->reset_base (); else this->set_profile_in_use_i (pfile_next); return pfile_next; } }

ACE_INLINE CORBA::Boolean TAO_Stub::next_profile_retry (  void   )

THREAD SAFE Used to get the next profile after the one being used has failed during the initial connect or send of the message! Definition at line 192 of file Stub.inl. References ACE_GUARD_RETURN, forward_profiles_, next_profile_i(), profile_success_, and reset_profiles_i(). Referenced by TAO::Synch_Twoway_Invocation::handle_system_exception(), and TAO_Default_Endpoint_Selector::select_endpoint(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->profile_lock_ptr_, 0)); if (this->profile_success_ && this->forward_profiles_) { // We have a forwarded reference that we have managed to *send* a message to // previously in the remote path only (but not counting object proxy broker ops). // @todo I can see little sense to this. It is at best highly inconsistent. sm. // In this case we are falling back from the forwarded IOR stright to the base IOR this->reset_profiles_i (); return true; } else if (this->next_profile_i ()) { return true; } return false; }

const TAO::ObjectKey & TAO_Stub::object_key (  void   )  const

Return the ObjectKey. Definition at line 221 of file Stub.cpp. References base_profiles_, forward_profiles_, TAO_MProfile::get_profile(), ACE_Guard< ACE_LOCK >::locked(), TAO_Profile::object_key(), and profile_in_use_. Referenced by TAO_ServerRequest::TAO_ServerRequest(). { // Return the profile in use's object key if you see one. if (this->profile_in_use_) return this->profile_in_use_->object_key (); if (this->forward_profiles_) { // Double-checked ACE_Guard<ACE_Lock> obj (*this->profile_lock_ptr_); if (obj.locked () != 0 && this->forward_profiles_ != 0) return this->forward_profiles_->get_profile (0)->object_key (); } // If no forwarded profiles, just use the base profile return this->base_profiles_.get_profile (0)->object_key (); }

ACE_INLINE TAO::Object_Proxy_Broker * TAO_Stub::object_proxy_broker (  void   )  const

Accessor for getting the object proxy broker pointer. CORBA::Objects using this stub use this for standard calls like is_a; get_interface; etc... Definition at line 280 of file Stub.inl. References object_proxy_broker_. { return this->object_proxy_broker_; }

ACE_INLINE void TAO_Stub::object_proxy_broker (  TAO::Object_Proxy_Broker *  proxy_broker  )

Mutator for setting the object proxy broker pointer. CORBA::Objects using this stub will use this for standard calls like is_a; get_interface; etc... Definition at line 286 of file Stub.inl. References object_proxy_broker_. Referenced by CORBA::Object::_proxy_broker(), and CORBA::Object::proxy_broker(). { this->object_proxy_broker_ = object_proxy_broker; }

TAO_Stub& TAO_Stub::operator= (  const TAO_Stub &   )  [private]

ACE_INLINE CORBA::Boolean TAO_Stub::optimize_collocation_objects (  void   )  const

Return the cached value from the ORB_Core. This flag indicates whether the stub code should make use of the collocation opportunities that are available to the ORB. Definition at line 299 of file Stub.inl. References collocation_opt_. Referenced by TAO::Narrow_Utils< T >::unchecked_narrow(). { return this->collocation_opt_; }

ACE_INLINE TAO_ORB_Core * TAO_Stub::orb_core (  void   )  const

Accessor. Definition at line 242 of file Stub.inl. References TAO_ORB_Core_Auto_Ptr::get(). Referenced by TAO::Profile_Transport_Resolver::get_connection_timeout(), TAO::Remote_Invocation::init_target_spec(), TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::Invocation_Adapter::invoke_i(), CORBA::Object::Object(), TAO::Profile_Transport_Resolver::resolve(), TAO::Remote_Invocation::send_message(), TAO::Invocation_Adapter::set_response_flags(), TAO::Profile_Transport_Resolver::try_connect_i(), and TAO::Profile_Transport_Resolver::use_parallel_connect(). { return this->orb_core_.get (); }

ACE_INLINE TAO_Profile * TAO_Stub::profile_in_use (  void   )

returns a pointer to the profile_in_use object. This object retains ownership of this profile. Definition at line 49 of file Stub.inl. References profile_in_use_. Referenced by CORBA::Object::_key(), and TAO_Default_Endpoint_Selector::select_endpoint(). { return this->profile_in_use_; }

ACE_INLINE ACE_Lock * TAO_Stub::profile_lock (  void   )  const

Return the Profile lock. This lock can be used at places where profiles need to be edited. Definition at line 20 of file Stub.inl. References profile_lock_ptr_. { return this->profile_lock_ptr_; }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void TAO_Stub::reset_base (   )  [private]

NON-THREAD-SAFE. Utility method which resets or initializes the base_profile list and forward flags. Definition at line 10 of file Stub.inl. References base_profiles_, TAO_MProfile::get_next(), profile_success_, TAO_MProfile::rewind(), and set_profile_in_use_i(). Referenced by base_profiles(), next_profile_i(), and reset_profiles_i(). { this->base_profiles_.rewind (); this->profile_success_ = false; this->set_profile_in_use_i (base_profiles_.get_next ()); }

ACE_INLINE void TAO_Stub::reset_forward (   )  [private]

NOT THREAD-SAFE. Utility method which pops all forward profile lists and resets the forward_profiles_ pointer. Definition at line 26 of file Stub.inl. References forward_back_one(), and forward_profiles_. Referenced by add_forward_profiles(), base_profiles(), and reset_profiles_i(). { while (this->forward_profiles_ != 0) this->forward_back_one (); }

ACE_INLINE void TAO_Stub::reset_profiles (  void   )

THREAD SAFE this method will reset the base profile list to reference the first profile and if there are anmy existing forward profiles they are reset. Definition at line 40 of file Stub.inl. References ACE_GUARD, and reset_profiles_i(). Referenced by TAO::Remote_Invocation::send_message(), TAO::Synch_Twoway_Invocation::wait_for_reply(), and ~TAO_Stub(). { ACE_MT (ACE_GUARD (ACE_Lock, guard, *this->profile_lock_ptr_)); this->reset_profiles_i (); }

ACE_INLINE void TAO_Stub::reset_profiles_i (  void   )  [protected]

NON-THREAD SAFE version of reset_profiles (void);. Definition at line 33 of file Stub.inl. References reset_base(), and reset_forward(). Referenced by next_profile_retry(), and reset_profiles(). { this->reset_forward (); this->reset_base (); }

ACE_INLINE void TAO_Stub::servant_orb (  CORBA::ORB_ptr  orb  )

Accesor and mutator for the servant ORB. Notice that the mutator assumes the ownership of the passed in ORB and the accesor does not return a copy of the orb since the accessing of the ORB is considered temporary. Definition at line 262 of file Stub.inl. References CORBA::ORB::_duplicate(), CORBA::ORB_ptr, and servant_orb_. Referenced by set_policy_overrides(). { this->servant_orb_ = CORBA::ORB::_duplicate (orb); }

ACE_INLINE CORBA::ORB_ptr TAO_Stub::servant_orb_ptr (  void   )

This returns a duplicated ORB pointer. Definition at line 255 of file Stub.inl. References CORBA::ORB::_duplicate(). Referenced by TAO::Collocated_Invocation::invoke(). { // Simply pass back the ORB pointer for temporary use. return CORBA::ORB::_duplicate (this->servant_orb_.in ()); }

ACE_INLINE CORBA::ORB_var & TAO_Stub::servant_orb_var (  void   )

This returns the ORB var itself (generally for temporary use). Definition at line 248 of file Stub.inl. References servant_orb_. Referenced by TAO_ORB_Core::collocation_strategy(), and TAO::Narrow_Utils< T >::unchecked_narrow(). { // Simply pass back the ORB pointer for temporary use. return this->servant_orb_; }

TAO_Stub * TAO_Stub::set_policy_overrides (  const CORBA::PolicyList &  policies, CORBA::SetOverrideType  set_add )  [virtual]

Definition at line 440 of file Stub.cpp. References base_profiles_, policies_, CORBA::PolicyList, ACE_Auto_Basic_Ptr< X >::release(), servant_orb(), and TAO_POLICY_OBJECT_SCOPE. Referenced by CORBA::Object::_set_policy_overrides(). { // Notice the use of an explicit constructor.... auto_ptr<TAO_Policy_Set> policy_manager ( new TAO_Policy_Set (TAO_POLICY_OBJECT_SCOPE)); if (set_add == CORBA::SET_OVERRIDE) { policy_manager->set_policy_overrides (policies, set_add); } else if (this->policies_ == 0) { policy_manager->set_policy_overrides (policies, CORBA::SET_OVERRIDE); } else { policy_manager->copy_from (this->policies_); policy_manager->set_policy_overrides (policies, set_add); } TAO_Stub* stub = this->orb_core_->create_stub (this->type_id.in (), this->base_profiles_); stub->policies_ = policy_manager.release (); // Copy the servant ORB if it is present. stub->servant_orb (this->servant_orb_var ().in ()); return stub; }

TAO_Profile * TAO_Stub::set_profile_in_use_i (  TAO_Profile *  pfile  )  [private]

Makes a copy of the profile and frees the existing profile_in_use. NOT THREAD SAFE Definition at line 327 of file Stub.cpp. References TAO_Profile::_decr_refcnt(), TAO_Profile::_incr_refcnt(), ACE_ERROR_RETURN, ACE_TEXT, LM_ERROR, and profile_in_use_. Referenced by next_profile_i(), and reset_base(). { TAO_Profile *const old = this->profile_in_use_; // Since we are actively using this profile we dont want // it to disappear, so increase the reference count by one!! if (pfile && (pfile->_incr_refcnt () == 0)) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) unable to increment profile ref!\n")), 0); } this->profile_in_use_ = pfile; if (old) old->_decr_refcnt (); return this->profile_in_use_; }

ACE_INLINE void TAO_Stub::set_valid_profile (  void   )

NON-THREAD-SAFE. Will set profile_success_ to 0. Definition at line 160 of file Stub.inl. References profile_success_. Referenced by TAO::Remote_Invocation::send_message(). { this->profile_success_ = true; }

ACE_INLINE TAO::Transport_Queueing_Strategy * TAO_Stub::transport_queueing_strategy (  void   )

Return the queueing strategy to be used in by the transport. Selection will be based on the SyncScope policies. Definition at line 305 of file Stub.inl. References Messaging::SyncScope. Referenced by TAO_Transport::check_buffering_constraints_i(), and TAO_Transport::send_asynchronous_message_i(). { #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) bool has_synchronization; Messaging::SyncScope scope; this->orb_core_->call_sync_scope_hook (this, has_synchronization, scope); if (has_synchronization == true) return this->orb_core_->get_transport_queueing_strategy (this, scope); #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ // No queueing strategy, let the transport use its default return 0; }

ACE_INLINE CORBA::Boolean TAO_Stub::valid_forward_profile (  void   )

Returns 1 if a forward profile has successfully been used. profile_success_ && forward_profiles_ Definition at line 154 of file Stub.inl. References forward_profiles_, and profile_success_. { return (this->profile_success_ && this->forward_profiles_); }

ACE_INLINE CORBA::Boolean TAO_Stub::valid_profile (  void   )  const

Returns TRUE if a connection was successful with at least one profile. Definition at line 166 of file Stub.inl. References profile_success_. { return this->profile_success_; }

---

Member Data Documentation

TAO_MProfile TAO_Stub::base_profiles_ [protected]

Ordered list of profiles for this object. Definition at line 362 of file Stub.h. Referenced by add_forward_profiles(), base_profiles(), create_ior_info(), forward_back_one(), hash(), make_profiles(), marshal(), next_profile_i(), object_key(), reset_base(), and set_policy_overrides().

TAO_Abstract_ServantBase* TAO_Stub::collocated_servant_ [protected]

Servant pointer. It is 0 except for collocated objects. Definition at line 350 of file Stub.h. Referenced by collocated_servant().

const CORBA::Boolean TAO_Stub::collocation_opt_ [protected]

This should be the same value as cached in the ORB_Core. The reason for caching this helps our generated code, notably the stubs to be decoubled from ORB_Core. Please do not move it away. Definition at line 408 of file Stub.h. Referenced by optimize_collocation_objects().

TAO_MProfile* TAO_Stub::forward_profiles_ [protected]

The list of forwarding profiles. This is actually implemented as a linked list of TAO_MProfile objects. Definition at line 366 of file Stub.h. Referenced by add_forward_profiles(), create_ior_info(), forward_back_one(), forward_profiles(), next_forward_profile(), next_profile_i(), next_profile_retry(), object_key(), reset_forward(), valid_forward_profile(), and ~TAO_Stub().

TAO_MProfile* TAO_Stub::forward_profiles_perm_ [protected]

Definition at line 370 of file Stub.h. Referenced by add_forward_profiles(), marshal(), next_forward_profile(), and next_profile_i().

IOP::IOR* TAO_Stub::forwarded_ior_info_ [protected]

Forwarded IOR info. Definition at line 399 of file Stub.h. Referenced by create_ior_info(), and ~TAO_Stub().

IOP::IOR* TAO_Stub::ior_info_ [protected]

The ior info. This is needed for GIOP 1.2, as the clients could receive an exception from the server asking for this info. The exception that the client receives is LOC_NEEDS_ADDRESSING_MODE. The data is set up here to be passed on to Invocation classes when they receive an exception. This info is for the base profiles that this class stores Definition at line 396 of file Stub.h. Referenced by create_ior_info(), and ~TAO_Stub().

CORBA::Boolean TAO_Stub::is_collocated_ [protected]

Flag that indicates that this stub is collocated (and that it belongs to an ORB for which collocation optimisation is active). Definition at line 338 of file Stub.h. Referenced by is_collocated().

TAO::Object_Proxy_Broker* TAO_Stub::object_proxy_broker_ [protected]

Pointer to the Proxy Broker. This cached pointer instance takes care of routing the call for standard calls in CORBA::Object like _is_a (), _get_component () etc. Definition at line 358 of file Stub.h. Referenced by is_collocated(), and object_proxy_broker().

CORBA::ORB_var TAO_Stub::orb_ [protected]

Todo: Why do we need both a reference to the ORB_Core and its ORB? It think the memory management rules for the ORB_Core changed, in the good old days it was the CORBA::ORB class who owned the ORB_Core, now it is the other way around.... Definition at line 334 of file Stub.h.

TAO_ORB_Core_Auto_Ptr TAO_Stub::orb_core_ [protected]

Automatically manage the ORB_Core reference count. The ORB_Core cannot go away until the object references it creates are destroyed. There are multiple reasons for this, but in particular, the allocators used for some of the TAO_Profile objects contained on each TAO_Stub are owned by the TAO_ORB_Core. This must be the first field of the class, otherwise the TAO_ORB_Core is destroyed too early! Definition at line 324 of file Stub.h.

TAO_Policy_Set* TAO_Stub::policies_ [protected]

The policy overrides in this object, if nil then use the default policies. Definition at line 386 of file Stub.h. Referenced by get_cached_policy(), get_policy(), get_policy_overrides(), set_policy_overrides(), and ~TAO_Stub().

TAO_Profile* TAO_Stub::profile_in_use_ [protected]

This is the profile that we are currently sending/receiving with. Definition at line 373 of file Stub.h. Referenced by add_forward_profiles(), base_profiles(), create_ior_info(), is_equivalent(), object_key(), profile_in_use(), set_profile_in_use_i(), and ~TAO_Stub().

ACE_Lock* TAO_Stub::profile_lock_ptr_ [protected]

Mutex to protect access to the forwarding profile. Definition at line 376 of file Stub.h. Referenced by profile_lock(), TAO_Stub(), and ~TAO_Stub().

CORBA::Boolean TAO_Stub::profile_success_ [protected]

Have we successfully talked to the forward profile yet? Definition at line 379 of file Stub.h. Referenced by add_forward_profiles(), next_profile_i(), next_profile_retry(), reset_base(), set_valid_profile(), valid_forward_profile(), and valid_profile().

ACE_Atomic_Op<TAO_SYNCH_MUTEX, unsigned long> TAO_Stub::refcount_ [protected]

Reference counter. Definition at line 382 of file Stub.h.

CORBA::ORB_var TAO_Stub::servant_orb_ [protected]

If this stub refers to a collocated object then we need to hold on to the servant's ORB (which may be different from the client ORB) so that, 1. we know that the ORB will stay alive long enough, and, 2. we can search for the servant/POA's status starting from the ORB's RootPOA. Definition at line 347 of file Stub.h. Referenced by servant_orb(), and servant_orb_var().

CORBA::String_var TAO_Stub::type_id

All objref representations carry around a type ID. Definition at line 96 of file Stub.h. Referenced by CORBA::Object::_is_a().

---

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

• Stub.h
• Stub.cpp
• Stub.inl

---