#include <Stub.h>
Collaboration diagram for TAO_Stub:
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 &) |
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.
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] |
void TAO_Stub::_decr_refcnt | ( | void | ) |
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.
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 }
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().
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 | ) |
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 }
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] |
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] |
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] |
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().