TAO_Stub Class Reference

TAO_Stub. More...

#include <Stub.h>

Collaboration diagram for TAO_Stub:

Collaboration graph
[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_Stubset_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_Lockprofile_lock (void) const
TAO_Profileprofile_in_use (void)
const TAO::ObjectKey & object_key (void) const
 Return the ObjectKey.
TAO_MProfilemake_profiles (void)
const TAO_MProfilebase_profiles (void) const
 Obtain a reference to the basic profile set.
TAO_MProfilebase_profiles (void)
 Obtain a reference to the basic profile set.
const TAO_MProfileforward_profiles (void) const
 Obtain a pointer to the forwarded profile set.
TAO_Profilenext_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_Profilebase_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_Coreorb_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_varservant_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_ServantBasecollocated_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_Profilenext_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_ServantBasecollocated_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_MProfileforward_profiles_
TAO_MProfileforward_profiles_perm_
TAO_Profileprofile_in_use_
 This is the profile that we are currently sending/receiving with.
ACE_Lockprofile_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_Setpolicies_
IOP::IOR * ior_info_
IOP::IOR * forwarded_ior_info_
 Forwarded IOR info.
const CORBA::Boolean collocation_opt_

Private Member Functions

TAO_Profileset_profile_in_use_i (TAO_Profile *pfile)
void reset_base ()
void forward_back_one (void)
void reset_forward ()
TAO_Profilenext_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_Stuboperator= (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, LM_DEBUG, TAO_debug_level, and TAO_ORB_Core_instance().

00039   : type_id (repository_id)
00040   , orb_core_ (orb_core)
00041   , orb_ ()
00042   , is_collocated_ (false)
00043   , servant_orb_ ()
00044   , collocated_servant_ (0)
00045   , object_proxy_broker_ (the_tao_remote_object_proxy_broker ())
00046   , base_profiles_ ((CORBA::ULong) 0)
00047   , forward_profiles_ (0)
00048   , forward_profiles_perm_ (0)
00049   , profile_in_use_ (0)
00050   , profile_lock_ptr_ (0)
00051   , profile_success_ (false)
00052   , refcount_ (1)
00053 #if (TAO_HAS_CORBA_MESSAGING == 1)
00054   , policies_ (0)
00055 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00056   , ior_info_ (0)
00057   , forwarded_ior_info_ (0)
00058   , collocation_opt_ (orb_core->optimize_collocation_objects ())
00059 {
00060   if (this->orb_core_.get() == 0)
00061     {
00062       if (TAO_debug_level > 0)
00063         {
00064           ACE_DEBUG ((LM_DEBUG,
00065                       ACE_TEXT ("TAO: (%P|%t) TAO_Stub created with default ")
00066                       ACE_TEXT ("ORB core\n")));
00067         }
00068 
00069       this->orb_core_.reset (TAO_ORB_Core_instance ());
00070     }
00071 
00072   // Duplicate the ORB_Core, otherwise the allocators and other
00073   // resources that this class references (directly or indirectly)
00074   // could be destroyed before it is time.
00075   (void) this->orb_core_->_incr_refcnt ();
00076 
00077   // Cache the ORB pointer to respond faster to certain queries.
00078   this->orb_ = CORBA::ORB::_duplicate (this->orb_core_->orb ());
00079 
00080   this->profile_lock_ptr_ =
00081     this->orb_core_->client_factory ()->create_profile_lock ();
00082 
00083   this->base_profiles (profiles);
00084 }

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 ACE_ASSERT, forwarded_ior_info_, ior_info_, policies_, and reset_profiles().

00087 {
00088   ACE_ASSERT (this->refcount_ == 0);
00089 
00090   if (this->forward_profiles_)
00091     reset_profiles ();
00092 
00093   // reset_profiles doesn't delete forward_profiles_perm_.
00094   delete this->forward_profiles_perm_;
00095 
00096   if (this->profile_in_use_ != 0)
00097     {
00098       // decrease reference count on profile
00099       this->profile_in_use_->_decr_refcnt ();
00100       this->profile_in_use_ = 0;
00101     }
00102 
00103   delete this->profile_lock_ptr_;
00104 
00105 #if (TAO_HAS_CORBA_MESSAGING == 1)
00106 
00107   delete this->policies_;
00108 
00109 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
00110 
00111   if (this->ior_info_)
00112     delete this->ior_info_;
00113 
00114   if (this->forwarded_ior_info_)
00115     delete this->forwarded_ior_info_;
00116 }

TAO_Stub::TAO_Stub ( const TAO_Stub  )  [private]


Member Function Documentation

void TAO_Stub::_decr_refcnt ( void   ) 

Definition at line 566 of file Stub.cpp.

00567 {
00568   if (--this->refcount_ == 0)
00569     delete this;
00570 }

void TAO_Stub::_incr_refcnt ( void   ) 

Definition at line 560 of file Stub.cpp.

References refcount_.

Referenced by TAO::Narrow_Utils< T >::unchecked_narrow().

00561 {
00562   ++this->refcount_;
00563 }

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 119 of file Stub.cpp.

References ACE_GUARD, ACE_NEW, base_profiles_, profile_success_, and reset_forward().

Referenced by TAO::LocateRequest_Invocation_Adapter::object_forwarded(), and TAO::Invocation_Adapter::object_forwarded().

00121 {
00122   // we assume that the profile_in_use_ is being
00123   // forwarded!  Grab the lock so things don't change.
00124   ACE_MT (ACE_GUARD (ACE_Lock,
00125                      guard,
00126                      *this->profile_lock_ptr_));
00127 
00128   if (permanent_forward)
00129     {
00130       // paranoid, reset the bookmark, then clear the forward-stack
00131       this->forward_profiles_perm_ = 0;
00132 
00133       this->reset_forward ();
00134     }
00135 
00136   TAO_MProfile *now_pfiles = this->forward_profiles_;
00137   if (now_pfiles == 0)
00138     now_pfiles = &this->base_profiles_;
00139 
00140   ACE_NEW (this->forward_profiles_,
00141            TAO_MProfile (mprofiles));
00142 
00143   if (permanent_forward)
00144     // bookmark the new element at bottom of stack
00145     this->forward_profiles_perm_ = this->forward_profiles_;
00146 
00147   // forwarded profile points to the new IOR (profiles)
00148   this->profile_in_use_->forward_to (this->forward_profiles_);
00149 
00150   // new profile list points back to the list which was forwarded.
00151   this->forward_profiles_->forward_from (now_pfiles);
00152 
00153   // make sure we start at the beginning of mprofiles
00154   this->forward_profiles_->rewind ();
00155 
00156   // Since we have been forwarded, we must set profile_success_ to false
00157   // since we are starting a new with a new set of profiles!
00158   this->profile_success_ = false;
00159 }

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 185 of file Stub.inl.

References ACE_GUARD_RETURN, base_profiles_, profile_in_use_, reset_base(), reset_forward(), and TAO_MProfile::set().

00186 {
00187   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00188                             guard,
00189                             *this->profile_lock_ptr_,
00190                             0));
00191 
00192   // first reset things so we start from scratch!
00193 
00194   // @note This reset forward could effect the collocation status
00195   // but as this method is only used from the Stub ctr, when the status
00196   // is already correctly set, we don't reinitialise here. sm.
00197   this->reset_forward ();
00198   this->base_profiles_.set (mprofiles);
00199   this->reset_base ();
00200   return this->profile_in_use_;
00201 
00202 }

ACE_INLINE TAO_MProfile & TAO_Stub::base_profiles ( void   ) 

Obtain a reference to the basic profile set.

Definition at line 240 of file Stub.inl.

References base_profiles_.

00241 {
00242   return this->base_profiles_;
00243 }

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

Obtain a reference to the basic profile set.

Definition at line 234 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(), and TAO_ORB_Core::reinitialize_object().

00235 {
00236   return this->base_profiles_;
00237 }

ACE_INLINE TAO_Abstract_ServantBase * TAO_Stub::collocated_servant ( void   )  const

Accessor for the servant reference in collocated cases.

Definition at line 284 of file Stub.inl.

References collocated_servant_.

00285 {
00286   return collocated_servant_;
00287 }

ACE_INLINE void TAO_Stub::collocated_servant ( TAO_Abstract_ServantBase servant  ) 

Mutator for setting the servant in collocated cases.

Definition at line 290 of file Stub.inl.

References collocated_servant_.

Referenced by CORBA::Object::_servant(), CORBA::Object::Object(), and CORBA::Object::set_collocated_servant().

00291 {
00292   this->collocated_servant_ = servant;
00293 }

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 162 of file Stub.cpp.

References ACE_GUARD_RETURN, base_profiles_, forwarded_ior_info_, get_profile_ior_info(), ior_info_, and TAO_MProfile::profile_count().

00163 {
00164   // We are creating the IOR info. Let us not be disturbed. So grab a
00165   // lock.
00166   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00167                             guard,
00168                             *this->profile_lock_ptr_,
00169                             -1));
00170 
00171   IOP::IOR *tmp_info = 0;
00172 
00173   if (this->forward_profiles_ != 0)
00174     {
00175       if (this->forwarded_ior_info_ == 0)
00176         {
00177           this->get_profile_ior_info (*this->forward_profiles_, tmp_info);
00178 
00179           this->forwarded_ior_info_ = tmp_info;
00180         }
00181 
00182       // First we look at the forward profiles to see whether the
00183       // profile_in_use is any of it.
00184       for (CORBA::ULong i = 0;
00185            i < this->forward_profiles_->profile_count ();
00186            ++i)
00187         {
00188           if (this->forward_profiles_->get_profile (i)
00189               == this->profile_in_use_)
00190             {
00191               ior_info = this->forwarded_ior_info_;
00192               index = i;
00193               return 0;
00194             }
00195         }
00196     }
00197 
00198   // Else we look at the base profiles
00199   if (this->ior_info_ == 0)
00200     {
00201       this->get_profile_ior_info (this->base_profiles_, tmp_info);
00202 
00203       this->ior_info_ = tmp_info;
00204     }
00205 
00206 
00207   for (CORBA::ULong ind = 0;
00208        ind < this->base_profiles_.profile_count ();
00209        ++ind)
00210     {
00211       if (this->base_profiles_.get_profile (ind) == this->profile_in_use_)
00212         {
00213           index = ind;
00214           ior_info = this->ior_info_;
00215           return 0;
00216         }
00217     }
00218 
00219   // Error, there was no match
00220   return -1;
00221 }

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 308 of file Stub.inl.

00309 {
00310   // The reference count better be zero at this point!
00311   delete this;
00312 }

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 352 of file Stub.cpp.

References base_profiles_, TAO_Profile::forward_to(), and TAO_MProfile::get_current_profile().

Referenced by next_forward_profile(), and reset_forward().

00353 {
00354   TAO_MProfile *from = forward_profiles_->forward_from ();
00355 
00356   // Only delete the forward location if it is not permanent
00357   if (this->forward_profiles_ != this->forward_profiles_perm_)
00358     delete this->forward_profiles_;
00359 
00360   // the current profile in this profile list is no
00361   // longer being forwarded, so set the reference to zero.
00362   if (from == &this->base_profiles_)
00363     {
00364       this->base_profiles_.get_current_profile ()->forward_to (0);
00365       this->forward_profiles_ = 0;
00366     }
00367   else
00368     {
00369       from->get_current_profile ()->forward_to (0);
00370       this->forward_profiles_ = from;
00371     }
00372 }

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

Obtain a pointer to the forwarded profile set.

Definition at line 246 of file Stub.inl.

References forward_profiles_.

Referenced by TAO_ORB_Core::reinitialize_object().

00247 {
00248   return this->forward_profiles_;
00249 }

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

Definition at line 425 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(), orb_core_, and policies_.

Referenced by CORBA::Object::_get_cached_policy().

00426 {
00427   // No need to lock, the stub only changes its policies at
00428   // construction time...
00429 
00430   CORBA::Policy_var result;
00431   if (this->policies_ != 0)
00432     {
00433       result = this->policies_->get_cached_policy (type);
00434     }
00435 
00436   if (CORBA::is_nil (result.in ()))
00437     {
00438       result = this->orb_core_->get_cached_policy_including_current (type);
00439     }
00440 
00441   return result._retn ();
00442 }

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 405 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(), orb_core_, and policies_.

Referenced by CORBA::Object::_get_policy().

00406 {
00407   // No need to lock, the stub only changes its policies at
00408   // construction time...
00409 
00410   CORBA::Policy_var result;
00411   if (this->policies_ != 0)
00412     {
00413       result = this->policies_->get_policy (type);
00414     }
00415 
00416   if (CORBA::is_nil (result.in ()))
00417     {
00418       result = this->orb_core_->get_policy_including_current (type);
00419     }
00420 
00421   return result._retn ();
00422 }

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

Definition at line 479 of file Stub.cpp.

References ACE_NEW_THROW_EX, TAO_Policy_Set::get_policy_overrides(), and policies_.

Referenced by CORBA::Object::_get_policy_overrides().

00480 {
00481   if (this->policies_ == 0)
00482     {
00483       CORBA::PolicyList *policy_list_ptr = 0;
00484       ACE_NEW_THROW_EX (policy_list_ptr,
00485                         CORBA::PolicyList (),
00486                         CORBA::NO_MEMORY ());
00487 
00488       return policy_list_ptr;
00489     }
00490   else
00491     {
00492       return this->policies_->get_policy_overrides (types);
00493     }
00494 }

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

THREAD-SAFE Create the IOR info.

Definition at line 244 of file Stub.cpp.

References ACE_NEW_THROW_EX, TAO_Profile::create_tagged_profile(), TAO_MProfile::get_profile(), and TAO_MProfile::profile_count().

Referenced by create_ior_info().

00245 {
00246   ACE_NEW_THROW_EX (ior_info,
00247                     IOP::IOR (),
00248                     CORBA::NO_MEMORY ());
00249 
00250   // Get the number of elements
00251   CORBA::ULong const count = profiles.profile_count ();
00252 
00253   // Set the number of elements in the sequence of tagged_profile
00254   ior_info->profiles.length (count);
00255 
00256   // Call the create_tagged_profile one every member of the
00257   // profile and make the sequence
00258   for (CORBA::ULong index = 0; index < count; ++index)
00259     {
00260       TAO_Profile *prof = profiles.get_profile (index);
00261 
00262       IOP::TaggedProfile *tp = prof->create_tagged_profile ();
00263 
00264       if (tp == 0)
00265         throw ::CORBA::NO_MEMORY ();
00266       ior_info->profiles[index] = *tp;
00267     }
00268 
00269   return 0;
00270 }

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 297 of file Stub.cpp.

References base_profiles_, and TAO_MProfile::hash().

Referenced by CORBA::Object::_hash().

00298 {
00299   // we rely on the profile objects that its address info
00300   return this->base_profiles_.hash (max);
00301 }

void TAO_Stub::is_collocated ( CORBA::Boolean   ) 

Mutator to mark this stub as being collocated with the servant.

Definition at line 273 of file Stub.cpp.

References _TAO_Object_Proxy_Broker_Factory_function_pointer, is_collocated_, object_proxy_broker_, and the_tao_remote_object_proxy_broker().

00274 {
00275   if (this->is_collocated_ != collocated)
00276     {
00277       if (collocated &&
00278           _TAO_Object_Proxy_Broker_Factory_function_pointer != 0)
00279         {
00280           this->object_proxy_broker_ =
00281             _TAO_Object_Proxy_Broker_Factory_function_pointer ();
00282         }
00283       else
00284         {
00285           this->object_proxy_broker_ = the_tao_remote_object_proxy_broker ();
00286         }
00287       this->is_collocated_ = collocated;
00288     }
00289 }

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

Is this stub collocated with the servant?

Definition at line 252 of file Stub.inl.

References is_collocated_.

Referenced by CORBA::Object::_is_collocated(), CORBA::Object::Object(), and CORBA::Object::set_collocated_servant().

00253 {
00254   return this->is_collocated_;
00255 }

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

Implement the is_equivalent() method for the CORBA::Object.

Definition at line 312 of file Stub.cpp.

References TAO_Profile::is_equivalent(), and CORBA::is_nil().

Referenced by CORBA::Object::_is_equivalent().

00313 {
00314   if (CORBA::is_nil (other_obj))
00315     return false;
00316 
00317   TAO_Profile * const other_profile = other_obj->_stubobj ()->profile_in_use_;
00318   TAO_Profile * const this_profile = this->profile_in_use_;
00319 
00320   if (other_profile == 0 || this_profile == 0)
00321     return false;
00322 
00323   // Compare the profiles
00324   return this_profile->is_equivalent (other_profile);
00325 }

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 69 of file Stub.inl.

References ACE_NEW_RETURN, and base_profiles_.

00070 {
00071   TAO_MProfile *mp = 0;
00072 
00073   ACE_NEW_RETURN (mp,
00074                   TAO_MProfile (base_profiles_),
00075                   0);
00076 
00077   return mp;
00078 }

CORBA::Boolean TAO_Stub::marshal ( TAO_OutputCDR  ) 

Needed to avoid copying forward_profiles for thread safety.

Definition at line 499 of file Stub.cpp.

References ACE_ASSERT, ACE_GUARD_RETURN, base_profiles_, TAO_MProfile::get_profile(), ACE_OutputCDR::good_bit(), and TAO_MProfile::profile_count().

Referenced by operator<<().

00500 {
00501   // do as many outside of locked else-branch as posssible
00502 
00503   // STRING, a type ID hint
00504   if ((cdr << this->type_id.in()) == 0)
00505     return 0;
00506 
00507   if ( ! this->forward_profiles_perm_)
00508     {
00509       const TAO_MProfile& mprofile = this->base_profiles_;
00510 
00511       CORBA::ULong const profile_count = mprofile.profile_count ();
00512       if ((cdr << profile_count) == 0)
00513         return 0;
00514 
00515     // @@ The MProfile should be locked during this iteration, is there
00516     // anyway to achieve that?
00517     for (CORBA::ULong i = 0; i < profile_count; ++i)
00518       {
00519         const TAO_Profile* p = mprofile.get_profile (i);
00520         if (p->encode (cdr) == 0)
00521           return 0;
00522       }
00523     }
00524   else
00525     {
00526       ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00527                                 guard,
00528                                 *this->profile_lock_ptr_,
00529                                 0));
00530 
00531       ACE_ASSERT(this->forward_profiles_ !=0);
00532 
00533       // paranoid - in case of FT the basic_profiles_ would do, too,
00534       // but might be dated
00535       const TAO_MProfile& mprofile =
00536           this->forward_profiles_perm_
00537         ? *(this->forward_profiles_perm_)
00538         : this->base_profiles_;
00539 
00540       CORBA::ULong const profile_count = mprofile.profile_count ();
00541       if ((cdr << profile_count) == 0)
00542            return 0;
00543 
00544       // @@ The MProfile should be locked during this iteration, is there
00545       // anyway to achieve that?
00546       for (CORBA::ULong i = 0; i < profile_count; ++i)
00547         {
00548           const TAO_Profile* p = mprofile.get_profile (i);
00549           if (p->encode (cdr) == 0)
00550             return 0;
00551         }
00552 
00553       // release ACE_Lock
00554     }
00555 
00556   return (CORBA::Boolean) cdr.good_bit ();
00557 }

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

NON-THREAD-SAFE. utility method for next_profile.

Definition at line 81 of file Stub.inl.

References forward_back_one().

Referenced by next_profile_i().

00082 {
00083   TAO_Profile *pfile_next = 0;
00084 
00085   while (this->forward_profiles_
00086          && (pfile_next = this->forward_profiles_->get_next ()) == 0
00087          && this->forward_profiles_ != this->forward_profiles_perm_)  // do not remove permanent forward from bottom of stack
00088     // that was the last profile.  Now we clean up our forward profiles.
00089     // since we own the forward MProfiles, we must delete them when done.
00090     this->forward_back_one ();
00091 
00092   return pfile_next;
00093 }

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 157 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().

00158 {
00159   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00160                             guard,
00161                             *this->profile_lock_ptr_,
00162                             0));
00163   return this->next_profile_i ();
00164 }

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

NON-THREAD SAFE version of next_profile (void).

Definition at line 96 of file Stub.inl.

References base_profiles_, forward_profiles_, TAO_MProfile::get_next(), next_forward_profile(), orb_core_, profile_success_, reset_base(), TAO_MProfile::rewind(), and set_profile_in_use_i().

Referenced by next_profile().

00097 {
00098   TAO_Profile *pfile_next = 0;
00099 
00100   // First handle the case that a permanent forward occured
00101   if (this->forward_profiles_perm_) // the permanent forward defined
00102                                     // at bottom of stack
00103                                     // forward_profiles_
00104     {
00105       // In case of permanent forward the base_profiles are ingored.
00106 
00107       pfile_next = this->next_forward_profile ();
00108 
00109       if (pfile_next == 0)
00110         {
00111           // COND: this->forward_profiles_ == this->forward_profiles_perm_
00112 
00113           // reached end of list of permanent forward profiles
00114           // now, reset forward_profiles_perm_
00115 
00116           this->forward_profiles_->rewind ();
00117           this->profile_success_ = false;
00118           this->set_profile_in_use_i (this->forward_profiles_->get_next());
00119         }
00120       else
00121         this->set_profile_in_use_i (pfile_next);
00122 
00123       // We may have been forwarded to / from a collocated situation
00124       // Check for this and apply / remove optimisation if required.
00125       this->orb_core_->reinitialize_object (this);
00126 
00127       return pfile_next;
00128     }
00129   else
00130     {
00131       if (this->forward_profiles_) // Now do the common operation
00132         {
00133           pfile_next = this->next_forward_profile ();
00134           if (pfile_next == 0)
00135             {
00136               // Fall back to base profiles
00137               pfile_next = this->base_profiles_.get_next ();
00138             }
00139 
00140           // We may have been forwarded to / from a collocated situation
00141           // Check for this and apply / remove optimisation if required.
00142           this->orb_core_->reinitialize_object (this);
00143         }
00144       else
00145         pfile_next = this->base_profiles_.get_next ();
00146 
00147       if (pfile_next == 0)
00148         this->reset_base ();
00149       else
00150         this->set_profile_in_use_i (pfile_next);
00151 
00152       return pfile_next;
00153    }
00154 }

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 205 of file Stub.inl.

References ACE_GUARD_RETURN, forward_profiles_perm_, and reset_profiles_i().

00206 {
00207   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00208                             guard,
00209                             *this->profile_lock_ptr_,
00210                             0));
00211 
00212   if (this->profile_success_ && this->forward_profiles_)
00213     {
00214       // We have a forwarded reference that we have managed to *send* a message to
00215       // previously in the remote path only (but not counting object proxy broker ops).
00216       // @todo I can see little sense to this. It is at best highly inconsistent. sm.
00217 
00218       // In this case we are falling back from the forwarded IOR stright to the base IOR
00219       this->reset_profiles_i ();
00220 
00221       // We used to return unconditional true at this point but this results in
00222       // infinite retries of any permanent location forward. This is undesirable.
00223       return !this->forward_profiles_perm_;
00224     }
00225   else if (this->next_profile_i ())
00226     {
00227       return true;
00228     }
00229 
00230   return false;
00231 }

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

Return the ObjectKey.

Definition at line 224 of file Stub.cpp.

References base_profiles_, TAO_MProfile::get_profile(), ACE_Guard< ACE_LOCK >::locked(), and TAO_Profile::object_key().

Referenced by TAO_ServerRequest::TAO_ServerRequest().

00225 {
00226   // Return the profile in use's object key if you see one.
00227   if (this->profile_in_use_)
00228     return this->profile_in_use_->object_key ();
00229 
00230   if (this->forward_profiles_)
00231     {
00232       // Double-checked
00233       ACE_Guard<ACE_Lock> obj (*this->profile_lock_ptr_);
00234 
00235       if (obj.locked () != 0 &&  this->forward_profiles_ != 0)
00236         return this->forward_profiles_->get_profile (0)->object_key ();
00237     }
00238 
00239   // If no forwarded profiles, just use the base profile
00240   return this->base_profiles_.get_profile (0)->object_key ();
00241 }

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 296 of file Stub.inl.

References object_proxy_broker_.

00297 {
00298   return this->object_proxy_broker_;
00299 }

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 302 of file Stub.inl.

References object_proxy_broker_.

Referenced by CORBA::Object::_proxy_broker(), and CORBA::Object::proxy_broker().

00303 {
00304   this->object_proxy_broker_ = object_proxy_broker;
00305 }

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 315 of file Stub.inl.

References collocation_opt_.

Referenced by TAO::Narrow_Utils< T >::unchecked_narrow().

00316 {
00317   return this->collocation_opt_;
00318 }

ACE_INLINE TAO_ORB_Core * TAO_Stub::orb_core ( void   )  const

Accessor.

Definition at line 258 of file Stub.inl.

References TAO_ORB_Core_Auto_Ptr::get(), and orb_core_.

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().

00259 {
00260   return this->orb_core_.get ();
00261 }

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 63 of file Stub.inl.

References profile_in_use_.

Referenced by CORBA::Object::_key().

00064 {
00065   return this->profile_in_use_;
00066 }

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_.

00021 {
00022   return this->profile_lock_ptr_;
00023 }

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().

00011 {
00012   this->base_profiles_.rewind ();
00013   this->profile_success_ = false;
00014 
00015   this->set_profile_in_use_i (base_profiles_.get_next ());
00016 }

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().

Referenced by add_forward_profiles(), base_profiles(), and reset_profiles_i().

00027 {
00028   while (this->forward_profiles_ != 0
00029          && this->forward_profiles_ != this->forward_profiles_perm_) // Disturbingly the permanent
00030                                                                      // forwarded profile lives at the  bottom
00031                                                                      // of this stack if it exists. Avoid deleting it.
00032     this->forward_back_one ();
00033 }

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 54 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().

00055 {
00056   ACE_MT (ACE_GUARD (ACE_Lock,
00057                      guard,
00058                      *this->profile_lock_ptr_));
00059   this->reset_profiles_i ();
00060 }

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

NON-THREAD SAFE version of reset_profiles (void);.

Definition at line 36 of file Stub.inl.

References forward_profiles_, forward_profiles_perm_, reset_base(), reset_forward(), TAO_MProfile::rewind(), and set_profile_in_use_i().

Referenced by next_profile_retry(), and reset_profiles().

00037 {
00038   this->reset_forward ();
00039   this->reset_base ();
00040 
00041   if (this->forward_profiles_perm_)
00042     {
00043       // The *permanent* forward is being kept in the transient
00044       // forward queue (??!). We have just nuked it. Put it back the way it was.
00045       // reset_base should have reset the profile success.
00046       // @todo We have knives in the spoon draw - TAO_Stub needs total rewrite.
00047       this->forward_profiles_ = this->forward_profiles_perm_;
00048       this->forward_profiles_->rewind ();
00049       this->set_profile_in_use_i (this->forward_profiles_->get_next ());
00050     }
00051 }

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 278 of file Stub.inl.

References CORBA::ORB::_duplicate(), and servant_orb_.

Referenced by set_policy_overrides().

00279 {
00280   this->servant_orb_ = CORBA::ORB::_duplicate (orb);
00281 }

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

This returns a duplicated ORB pointer.

Definition at line 271 of file Stub.inl.

References CORBA::ORB::_duplicate().

Referenced by TAO::Collocated_Invocation::invoke().

00272 {
00273   // Simply pass back the ORB pointer for temporary use.
00274   return CORBA::ORB::_duplicate (this->servant_orb_.in ());
00275 }

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

This returns the ORB var itself (generally for temporary use).

Definition at line 264 of file Stub.inl.

References servant_orb_.

Referenced by TAO_ORB_Core::collocation_strategy(), and TAO::Narrow_Utils< T >::unchecked_narrow().

00265 {
00266   // Simply pass back the ORB pointer for temporary use.
00267   return this->servant_orb_;
00268 }

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

Definition at line 445 of file Stub.cpp.

References base_profiles_, orb_core_, policies_, ACE_Auto_Basic_Ptr< X >::release(), servant_orb(), and TAO_POLICY_OBJECT_SCOPE.

Referenced by CORBA::Object::_set_policy_overrides().

00447 {
00448   // Notice the use of an explicit constructor....
00449   auto_ptr<TAO_Policy_Set> policy_manager (
00450     new TAO_Policy_Set (TAO_POLICY_OBJECT_SCOPE));
00451 
00452   if (set_add == CORBA::SET_OVERRIDE)
00453     {
00454       policy_manager->set_policy_overrides (policies, set_add);
00455     }
00456   else if (this->policies_ == 0)
00457     {
00458       policy_manager->set_policy_overrides (policies, CORBA::SET_OVERRIDE);
00459     }
00460   else
00461     {
00462       policy_manager->copy_from (this->policies_);
00463 
00464       policy_manager->set_policy_overrides (policies, set_add);
00465     }
00466 
00467   TAO_Stub* stub = this->orb_core_->create_stub (this->type_id.in (),
00468                                                  this->base_profiles_);
00469 
00470   stub->policies_ = policy_manager.release ();
00471 
00472   // Copy the servant ORB if it is present.
00473   stub->servant_orb (this->servant_orb_var ().in ());
00474 
00475   return stub;
00476 }

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 330 of file Stub.cpp.

References TAO_Profile::_decr_refcnt(), TAO_Profile::_incr_refcnt(), ACE_ERROR_RETURN, ACE_TEXT, and LM_ERROR.

Referenced by next_profile_i(), reset_base(), and reset_profiles_i().

00331 {
00332   TAO_Profile *const old = this->profile_in_use_;
00333 
00334   // Since we are actively using this profile we dont want
00335   // it to disappear, so increase the reference count by one!!
00336   if (pfile && (pfile->_incr_refcnt () == 0))
00337     {
00338       ACE_ERROR_RETURN ((LM_ERROR,
00339                         ACE_TEXT ("(%P|%t) unable to increment profile ref!\n")),
00340                         0);
00341     }
00342 
00343   this->profile_in_use_ = pfile;
00344 
00345   if (old)
00346     old->_decr_refcnt ();
00347 
00348   return this->profile_in_use_;
00349 }

ACE_INLINE void TAO_Stub::set_valid_profile ( void   ) 

NON-THREAD-SAFE. Will set profile_success_ to 0.

Definition at line 173 of file Stub.inl.

References profile_success_.

Referenced by TAO::Remote_Invocation::send_message().

00174 {
00175   this->profile_success_ = true;
00176 }

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 321 of file Stub.inl.

References orb_core_.

Referenced by TAO_Transport::check_buffering_constraints_i(), and TAO_Transport::send_asynchronous_message_i().

00322 {
00323 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
00324 
00325   bool has_synchronization;
00326   Messaging::SyncScope scope;
00327 
00328   this->orb_core_->call_sync_scope_hook (this, has_synchronization, scope);
00329 
00330   if (has_synchronization == true)
00331     return this->orb_core_->get_transport_queueing_strategy  (this, scope);
00332 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
00333 
00334   // No queueing strategy, let the transport use its default
00335   return 0;
00336 }

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 167 of file Stub.inl.

00168 {
00169   return (this->profile_success_ && this->forward_profiles_);
00170 }

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 179 of file Stub.inl.

References profile_success_.

00180 {
00181   return this->profile_success_;
00182 }


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 forward_profiles(), next_profile_i(), and reset_profiles_i().

TAO_MProfile* TAO_Stub::forward_profiles_perm_ [protected]

Definition at line 370 of file Stub.h.

Referenced by next_profile_retry(), and reset_profiles_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.

Referenced by get_cached_policy(), get_policy(), next_profile_i(), orb_core(), set_policy_overrides(), and transport_queueing_strategy().

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 base_profiles(), and profile_in_use().

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().

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(), reset_base(), set_valid_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.

Referenced by _incr_refcnt().

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.


The documentation for this class was generated from the following files:
Generated on Tue Feb 2 17:39:46 2010 for TAO by  doxygen 1.4.7