Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

CORBA::Object Class Reference

Implementation of a CORBA object reference. More...

#include <Object.h>

Inheritance diagram for CORBA::Object:

Inheritance graph
[legend]
Collaboration diagram for CORBA::Object:

Collaboration graph
[legend]
List of all members.

Spec defined methods

virtual CORBA::Boolean _is_a (const char *logical_type_id)
 Determine if we are of the type specified by the "logical_type_id".

virtual const char * _interface_repository_id (void) const
virtual CORBA::ULong _hash (CORBA::ULong maximum)
virtual CORBA::Boolean _is_equivalent (CORBA::Object_ptr other_obj)
virtual CORBA::Boolean _non_existent (void)
 Determine if we are of the type specified by the "logical_type_id".

virtual CORBA::ImplementationDef_ptr _get_implementation (void)
virtual InterfaceDef_ptr _get_interface (void)
 Get info about the object from the Interface Repository.

virtual CORBA::Object_ptr _get_component (void)
 Get info about the object from the Interface Repository.

virtual char * _repository_id (void)
 Get the repository id.

virtual void _create_request (CORBA::Context_ptr ctx, const char *operation, CORBA::NVList_ptr arg_list, CORBA::NamedValue_ptr result, CORBA::Request_ptr &request, CORBA::Flags req_flags)
 Determine if we are of the type specified by the "logical_type_id".

virtual void _create_request (CORBA::Context_ptr ctx, const char *operation, CORBA::NVList_ptr arg_list, CORBA::NamedValue_ptr result, CORBA::ExceptionList_ptr exclist, CORBA::ContextList_ptr ctxtlist, CORBA::Request_ptr &request, CORBA::Flags req_flags)
 Determine if we are of the type specified by the "logical_type_id".

virtual CORBA::Request_ptr _request (const char *operation)
 DII operation to create a request.

CORBA::Policy_ptr _get_policy (CORBA::PolicyType type)
 Determine if we are of the type specified by the "logical_type_id".

CORBA::Policy_ptr _get_cached_policy (TAO_Cached_Policy_Type type)
 Determine if we are of the type specified by the "logical_type_id".

CORBA::Object_ptr _set_policy_overrides (const CORBA::PolicyList &policies, CORBA::SetOverrideType set_add)
 Determine if we are of the type specified by the "logical_type_id".

CORBA::PolicyList * _get_policy_overrides (const CORBA::PolicyTypeSeq &types)
 Determine if we are of the type specified by the "logical_type_id".

CORBA::Boolean _validate_connection (CORBA::PolicyList_out inconsistent_policies)
 Determine if we are of the type specified by the "logical_type_id".

virtual CORBA::ORB_ptr _get_orb (void)
 Determine if we are of the type specified by the "logical_type_id".

CORBA::Object_ptr _duplicate (CORBA::Object_ptr obj)
 Increment the ref count.

CORBA::Object_ptr _nil (void)
 Return a NULL object.

CORBA::Object_ptr _narrow (CORBA::Object_ptr obj)
 No-op it is just here to simplify some templates.


Methods that are TAO specific.

These methods are defined here as helper functions to be used by other parts of TAO. Theoretically they shold all start with tao_. But we have deviated from that principle.

virtual TAO_Abstract_ServantBase * _servant (void) const
virtual CORBA::Boolean _is_collocated (void) const
virtual CORBA::Boolean _is_local (void) const
 Is this a local object?

virtual TAO::ObjectKey * _key (void)
 Object (TAO_Stub *p, CORBA::Boolean collocated=0, TAO_Abstract_ServantBase *servant=0, TAO_ORB_Core *orb_core=0)
 Constructor.

 Object (IOP::IOR *ior, TAO_ORB_Core *orb_core=0)
virtual TAO_Stub * _stubobj (void) const
 Get the underlying stub object.

virtual TAO_Stub * _stubobj (void)
virtual void _proxy_broker (TAO::Object_Proxy_Broker *proxy_broker)
 Set the proxy broker.

virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr)
 Allows us to forbid marshaling of local interfaces.

CORBA::Boolean is_evaluated (void) const
 Accessor to the flag..

void set_collocated_servant (TAO_Abstract_ServantBase *)
 Mutator for setting the servant in collocated cases.

TAO_ORB_Core * orb_core (void) const
 Accessor for the ORB_Core..

IOP::IOR * steal_ior (void)
 Accessors for the underlying IOP::IOR's.

const IOP::IOR & ior (void) const
CORBA::Boolean marshal (const Object_ptr x, TAO_OutputCDR &cdr)
void _tao_any_destructor (void *)
 Used in the implementation of CORBA::Any.

CORBA::Boolean is_nil_i (CORBA::Object_ptr obj)
 Uninlined part of the now-inlined CORBA::is_nil().

void tao_object_initialize (Object *)
 Helper function for reading contents of an IOR.

void _tao_actual_add_ref (void)
void _tao_actual_remove_ref (void)

Public Types

typedef Object_ptr _ptr_type
typedef Object_var _var_type
typedef Object_out _out_type

Public Member Functions

virtual ~Object (void)
 Destructor.

virtual bool can_convert_to_ior (void) const
 Can this object be stringified?

virtual char * convert_to_ior (bool use_omg_ior_format, const char *ior_prefix) const
Reference Count Managment
These are the standard CORBA object reference count manipulations methods.

virtual void _add_ref (void)
 Increment the reference count.

virtual void _remove_ref (void)
 Decrement the reference count.


Protected Member Functions

 Object (int dummy=0)
 Initializing a local object.

TAO::Object_Proxy_Broker * proxy_broker () const

Protected Attributes

TAO_Configurable_Refcount refcount_
 Number of outstanding references to this object.


Private Member Functions

 Object (const Object &)
Object & operator= (const Object &)

Private Attributes

CORBA::Boolean is_local_
 Specify whether this is a local object or not.

CORBA::Boolean is_evaluated_
 Flag to indicate whether the IOP::IOR has been evaluated fully.

IOP::IOR_var ior_
TAO_ORB_Core * orb_core_
 Cached pointer of our ORB_Core.

TAO_Stub * protocol_proxy_
ACE_Lock * object_init_lock_
 Protect reference count manipulation from race conditions.

Detailed Description

Implementation of a CORBA object reference.

All CORBA objects, both unconstrained and locality-constrained, inherit from this class. The interface is defined in the CORBA specification and the C++ mapping.

Definition at line 101 of file Object.h.

Member Typedef Documentation

typedef Object_out CORBA::Object::_out_type
 

Reimplemented in CORBA::LocalObject, and CORBA::Policy.

Definition at line 244 of file Object.h.

typedef Object_ptr CORBA::Object::_ptr_type
 

Reimplemented in CORBA::LocalObject, and CORBA::Policy.

Definition at line 242 of file Object.h.

typedef Object_var CORBA::Object::_var_type
 

Reimplemented in CORBA::LocalObject, and CORBA::Policy.

Definition at line 243 of file Object.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL CORBA::Object::~Object (  void   )  [virtual]
 

Destructor.

Definition at line 38 of file Object.cpp.

References TAO_Stub::_decr_refcnt(), object_init_lock_, and protocol_proxy_. 

00039 {
00040   if (this->protocol_proxy_)
00041     (void) this->protocol_proxy_->_decr_refcnt ();
00042 
00043   delete this->object_init_lock_;
00044 }

CORBA::Object::Object (  TAO_Stub *  p,
CORBA::Boolean  collocated = 0,
TAO_Abstract_ServantBase *  servant = 0,
TAO_ORB_Core *  orb_core = 0
) 
 

Constructor.

This constructor should not be called when the protocol proxy is null ie. when the object is a LocalObject. Assert that requirement.

Definition at line 46 of file Object.cpp.

References ACE_ASSERT, TAO_Stub::collocated_servant(), TAO_Resource_Factory::create_corba_object_lock(), TAO_Resource_Factory::create_corba_object_refcount(), TAO_Stub::is_collocated(), object_init_lock_, TAO_Stub::orb_core(), protocol_proxy_, and TAO_ORB_Core::resource_factory(). 

00050   : is_local_ (false)
00051     , is_evaluated_ (true)
00052     , ior_ (0)
00053     , orb_core_ (orb_core)
00054     , protocol_proxy_ (protocol_proxy)
00055     , object_init_lock_ (0)
00056 {
00057   /// This constructor should not be called when the protocol proxy is
00058   /// null ie. when the object is a LocalObject. Assert that
00059   /// requirement.
00060   ACE_ASSERT (this->protocol_proxy_ != 0);
00061 
00062   if (this->orb_core_ == 0)
00063     this->orb_core_ = this->protocol_proxy_->orb_core ();
00064 
00065   this->object_init_lock_ =
00066     this->orb_core_->resource_factory ()->create_corba_object_lock ();
00067 
00068   this->refcount_ =
00069     this->orb_core_->resource_factory ()->create_corba_object_refcount ();
00070 
00071   // Set the collocation marker on the stub. This may not be news to it.
00072   // This may also change the stub's object proxy broker.
00073   this->protocol_proxy_->is_collocated (collocated);
00074 
00075   // Set the collocated servant pointer (null if not collocated) on the stub.
00076   this->protocol_proxy_->collocated_servant (servant);
00077 }

CORBA::Object::Object (  IOP::IOR *  ior,
TAO_ORB_Core *  orb_core = 0
) 
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 79 of file Object.cpp.

References TAO_Resource_Factory::create_corba_object_lock(), TAO_Resource_Factory::create_corba_object_refcount(), object_init_lock_, and TAO_ORB_Core::resource_factory(). 

00081   : is_local_ (false)
00082     , is_evaluated_ (false)
00083     , ior_ (ior)
00084     , orb_core_ (orb_core)
00085     , protocol_proxy_ (0)
00086     , object_init_lock_ (0)
00087 {
00088   this->object_init_lock_ =
00089     this->orb_core_->resource_factory ()->create_corba_object_lock ();
00090 
00091   this->refcount_ =
00092     this->orb_core_->resource_factory ()->create_corba_object_refcount ();
00093 }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE CORBA::Object::Object (  int  dummy = 0  )  [protected]
 

Initializing a local object.

Definition at line 10 of file Object.inl. 

00011   : is_local_ (true),
00012     is_evaluated_ (true),
00013     ior_ (),
00014     orb_core_ (0),
00015     protocol_proxy_ (0),
00016     object_init_lock_ (0)
00017 {
00018 }

CORBA::Object::Object (  const Object &   )  [private]
 

Member Function Documentation

void CORBA::Object::_add_ref (  void   )  [virtual]
 

Increment the reference count.

Reimplemented in CORBA::LocalObject, and TAO_Local_RefCounted_Object.

Definition at line 114 of file Object.cpp.

References _tao_actual_add_ref(), and is_local_.

Referenced by CORBA::Policy::_duplicate(), and _duplicate(). 

00115 {
00116   if (this->is_local_)
00117     return;
00118 
00119   this->_tao_actual_add_ref ();
00120 }

void CORBA::Object::_create_request (  CORBA::Context_ptr  ctx,
const char *  operation,
CORBA::NVList_ptr  arg_list,
CORBA::NamedValue_ptr  result,
CORBA::ExceptionList_ptr  exclist,
CORBA::ContextList_ptr  ctxtlist,
CORBA::Request_ptr &  request,
CORBA::Flags  req_flags
)  [virtual]
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 410 of file Object.cpp.

References CORBA::Context_ptr, CORBA::ContextList_ptr, TAO_Dynamic_Adapter::create_request(), CORBA::ExceptionList_ptr, CORBA::Flags, ACE_Dynamic_Service< TYPE >::instance(), CORBA::NamedValue_ptr, CORBA::NVList_ptr, protocol_proxy_, CORBA::Request_ptr, and TAO_OBJECT_IOR_EVALUATE. 

00418 {
00419   TAO_OBJECT_IOR_EVALUATE;
00420 
00421   // Since we don't really support Context, anything but a null pointer
00422   // is a no-no.
00423   // Neither can we create a request object from locality constrained
00424   // object references.
00425   if (ctx != 0 || this->protocol_proxy_ == 0)
00426     {
00427       throw ::CORBA::NO_IMPLEMENT ();
00428     }
00429 
00430   TAO_Dynamic_Adapter *dynamic_adapter =
00431     ACE_Dynamic_Service<TAO_Dynamic_Adapter>::instance (
00432         TAO_ORB_Core::dynamic_adapter_name ()
00433       );
00434 
00435   dynamic_adapter->create_request (
00436                        this,
00437                        this->protocol_proxy_->orb_core ()-> orb (),
00438                        operation,
00439                        arg_list,
00440                        result,
00441                        exceptions,
00442                        request,
00443                        req_flags);
00444 }

void CORBA::Object::_create_request (  CORBA::Context_ptr  ctx,
const char *  operation,
CORBA::NVList_ptr  arg_list,
CORBA::NamedValue_ptr  result,
CORBA::Request_ptr &  request,
CORBA::Flags  req_flags
)  [virtual]
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 372 of file Object.cpp.

References CORBA::Context_ptr, TAO_Dynamic_Adapter::create_request(), CORBA::Flags, ACE_Dynamic_Service< TYPE >::instance(), CORBA::NamedValue_ptr, CORBA::NVList_ptr, protocol_proxy_, CORBA::Request_ptr, and TAO_OBJECT_IOR_EVALUATE. 

00378 {
00379   TAO_OBJECT_IOR_EVALUATE;
00380 
00381   // Since we don't really support Context, anything but a null pointer
00382   // is a no-no.
00383   // Neither can we create a request object from locality constrained
00384   // object references.
00385   if (ctx != 0 || this->protocol_proxy_ == 0)
00386     {
00387       throw ::CORBA::NO_IMPLEMENT ();
00388     }
00389 
00390   TAO_Dynamic_Adapter *dynamic_adapter =
00391     ACE_Dynamic_Service<TAO_Dynamic_Adapter>::instance (
00392         TAO_ORB_Core::dynamic_adapter_name ()
00393       );
00394 
00395   dynamic_adapter->create_request (
00396                        this,
00397                        this->protocol_proxy_->orb_core ()-> orb (),
00398                        operation,
00399                        arg_list,
00400                        result,
00401                        0,
00402                        request,
00403                        req_flags
00404                      );
00405 }

ACE_INLINE CORBA::Object_ptr CORBA::Object::_duplicate (  CORBA::Object_ptr  obj  )  [static]
 

Increment the ref count.

Definition at line 21 of file Object.inl.

References _add_ref(), and CORBA::Object_ptr.

Referenced by _narrow(), TAO_Object_Ref_Table::find(), TAO_ServerRequest::forward_location(), TAO::Invocation_Base::forwarded_reference(), TAO_ORB_Core::implrepo_service(), TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::Invocation_Adapter::invoke_i(), TAO::Objref_Traits< CORBA::Object >::duplicate(), TAO_ORB_Core::resolve_codecfactory(), TAO_ORB_Core::resolve_compression_manager(), TAO_ORB_Core::resolve_dynanyfactory(), TAO_ORB_Core::resolve_ior_manipulation(), TAO_ORB_Core::resolve_ior_table(), TAO_ORB_Core::resolve_picurrent(), TAO_ORB_Core::resolve_poa_current(), CORBA::ORB::resolve_policy_current(), CORBA::ORB::resolve_policy_manager(), TAO_ORB_Core::resolve_rt_orb(), TAO_ORB_Core::resolve_typecodefactory(), and TAO_ORB_Core::root_poa(). 

00022 {
00023   if (obj)
00024     {
00025       obj->_add_ref ();
00026     }
00027 
00028   return obj;
00029 }

CORBA::Policy_ptr CORBA::Object::_get_cached_policy (  TAO_Cached_Policy_Type  type  ) 
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 544 of file Object.cpp.

References TAO_Stub::get_cached_policy(), protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00545 {
00546   TAO_OBJECT_IOR_EVALUATE_RETURN;
00547 
00548   if (this->protocol_proxy_)
00549     return this->protocol_proxy_->get_cached_policy (type);
00550   else
00551     throw ::CORBA::NO_IMPLEMENT ();
00552 }

CORBA::Object_ptr CORBA::Object::_get_component (  void   )  [virtual]
 

Get info about the object from the Interface Repository.

Reimplemented in CORBA::LocalObject.

Definition at line 508 of file Object.cpp.

References TAO::Object_Proxy_Broker::_get_component(), proxy_broker(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00509 {
00510   TAO_OBJECT_IOR_EVALUATE_RETURN;
00511   return this->proxy_broker ()->_get_component (this);
00512 }

CORBA::ImplementationDef_ptr CORBA::Object::_get_implementation (  void   )  [virtual]
 

This method is deprecated in the CORBA 2.2 spec, we just return 0 every time.

Reimplemented in CORBA::LocalObject.

Definition at line 502 of file Object.cpp. 

00503 {
00504   return 0;
00505 }

CORBA::InterfaceDef_ptr CORBA::Object::_get_interface (  void   )  [virtual]
 

Get info about the object from the Interface Repository.

Reimplemented in CORBA::LocalObject.

Definition at line 495 of file Object.cpp.

References TAO::Object_Proxy_Broker::_get_interface(), proxy_broker(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00496 {
00497   TAO_OBJECT_IOR_EVALUATE_RETURN;
00498   return this->proxy_broker ()->_get_interface (this);
00499 }

CORBA::ORB_ptr CORBA::Object::_get_orb (  void   )  [virtual]
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 640 of file Object.cpp.

References CORBA::ORB::_duplicate(), protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00641 {
00642   if (this->orb_core_ != 0)
00643     {
00644       return CORBA::ORB::_duplicate (this->orb_core_->orb ());
00645     }
00646   else
00647     {
00648       TAO_OBJECT_IOR_EVALUATE_RETURN;
00649       if (this->protocol_proxy_)
00650         return CORBA::ORB::_duplicate (this->protocol_proxy_->orb_core ()->orb ());
00651       else
00652         throw ::CORBA::INTERNAL ();
00653     }
00654 }

CORBA::Policy_ptr CORBA::Object::_get_policy (  CORBA::PolicyType  type  ) 
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 533 of file Object.cpp.

References TAO_Stub::get_policy(), CORBA::PolicyType, protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00534 {
00535   TAO_OBJECT_IOR_EVALUATE_RETURN;
00536 
00537   if (this->protocol_proxy_)
00538     return this->protocol_proxy_->get_policy (type);
00539   else
00540     throw ::CORBA::NO_IMPLEMENT ();
00541 }

CORBA::PolicyList * CORBA::Object::_get_policy_overrides (  const CORBA::PolicyTypeSeq &  types  ) 
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 593 of file Object.cpp.

References TAO_Stub::get_policy_overrides(), CORBA::PolicyTypeSeq, protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00594 {
00595   TAO_OBJECT_IOR_EVALUATE_RETURN;
00596   if (this->protocol_proxy_)
00597     return this->protocol_proxy_->get_policy_overrides (types);
00598   else
00599     throw ::CORBA::NO_IMPLEMENT ();
00600 }

CORBA::ULong CORBA::Object::_hash (  CORBA::ULong  maximum  )  [virtual]
 

Return a (potentially non-unique) hash value for this object. This method relies on the representation of the object reference's private state. Since that changes easily (when different ORB protocols are in use) there is no default implementation.

Reimplemented in CORBA::LocalObject.

Definition at line 282 of file Object.cpp.

References TAO_Stub::hash(), protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00283 {
00284   TAO_OBJECT_IOR_EVALUATE_RETURN;
00285 
00286   if (this->protocol_proxy_ != 0)
00287     return this->protocol_proxy_->hash (maximum);
00288   else
00289     {
00290       // Locality-constrained object.
00291 
00292       // Note that we reinterpret_cast to an "unsigned long" instead
00293       // of CORBA::ULong since we need to first cast to an integer
00294       // large enough to hold an address to avoid compile-time
00295       // warnings on some 64-bit platforms.
00296       const CORBA::ULong hash =
00297         static_cast<CORBA::ULong> (reinterpret_cast<ptrdiff_t> (this));
00298 
00299       return hash % maximum;
00300     }
00301 }

const char * CORBA::Object::_interface_repository_id (  void   )  const [virtual]
 

The repository ID for the most derived class, this is an implementation method and does no remote invocations!

Reimplemented in CORBA::Policy.

Definition at line 239 of file Object.cpp. 

00240 {
00241   return "IDL:omg.org/CORBA/Object:1.0";
00242 }

CORBA::Boolean CORBA::Object::_is_a (  const char *  logical_type_id  )  [virtual]
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::Policy.

Definition at line 207 of file Object.cpp.

References TAO::Object_Proxy_Broker::_is_a(), _stubobj(), TAO::String_var< charT >::in(), protocol_proxy_, proxy_broker(), ACE_OS::strcmp(), TAO_OBJECT_IOR_EVALUATE_RETURN, and TAO_Stub::type_id.

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

00208 {
00209   TAO_OBJECT_IOR_EVALUATE_RETURN;
00210 
00211   // NOTE: if istub->type_id is nonzero and we have local knowledge of
00212   // it, we can answer this question without a costly remote call.
00213   //
00214   // That "local knowledge" could come from stubs or skeletons linked
00215   // into this process in the best case, or a "near" repository in a
00216   // slightly worse case.  Or in a trivial case, if the ID being asked
00217   // about is the ID we have recorded, we don't need to ask about the
00218   // inheritance relationships at all!
00219   //
00220   // In real systems having local knowledge will be common, though as
00221   // the systems built atop ORBs become richer it'll also become
00222   // common to have the "real type ID" not be directly understood
00223   // because it's more deeply derived than any locally known types.
00224   //
00225   // XXX if type_id is that of CORBA::Object, "yes, we comply" :-)
00226 
00227   if (this->protocol_proxy_ == 0)
00228     throw ::CORBA::NO_IMPLEMENT ();
00229 
00230   if (this->_stubobj ()->type_id.in () != 0
00231       && ACE_OS::strcmp (type_id,
00232                          this->_stubobj ()->type_id.in ()) == 0)
00233     return true;
00234 
00235   return this->proxy_broker ()->_is_a (this, type_id);
00236 }

CORBA::Boolean CORBA::Object::_is_collocated (  void   )  const [virtual]
 

Is this object collocated with the servant? Note this does not return this->is_collocated_ but will instead query the underlying stub for its collocation status

Definition at line 245 of file Object.cpp.

References TAO_Stub::is_collocated(), and protocol_proxy_.

Referenced by _validate_connection(), TAO_Default_Collocation_Resolver::is_collocated(), and TAO::Narrow_Utils< T >::unchecked_narrow(). 

00246 {
00247   if (this->protocol_proxy_)
00248     {
00249       return this->protocol_proxy_->is_collocated ();
00250     }
00251 
00252   return false;
00253 }

CORBA::Boolean CORBA::Object::_is_equivalent (  CORBA::Object_ptr  other_obj  )  [virtual]
 

Try to determine if this object is the same as other_obj. This method relies on the representation of the object reference's private state. Since that changes easily (when different ORB protocols are in use) there is no default implementation.

Reimplemented in CORBA::LocalObject.

Definition at line 304 of file Object.cpp.

References TAO_Stub::is_equivalent(), CORBA::Object_ptr, protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00305 {
00306   if (other_obj == this)
00307     {
00308       return true;
00309     }
00310 
00311   TAO_OBJECT_IOR_EVALUATE_RETURN;
00312 
00313   if (this->protocol_proxy_ != 0)
00314     return this->protocol_proxy_->is_equivalent (other_obj);
00315 
00316   return false;
00317 }

CORBA::Boolean CORBA::Object::_is_local (  void   )  const [virtual]
 

Is this a local object?

Definition at line 263 of file Object.cpp.

References is_local_.

Referenced by CORBA::LocalObject::_narrow(), can_convert_to_ior(), and TAO::Narrow_Utils< T >::unchecked_narrow(). 

00264 {
00265   return this->is_local_;
00266 }

TAO::ObjectKey * CORBA::Object::_key (  void   )  [virtual]
 

Return the object key as an out parameter. Caller should release return value when finished with it.

Reimplemented in CORBA::LocalObject.

Definition at line 322 of file Object.cpp.

References TAO_Profile::_key(), _stubobj(), ACE_ERROR, ACE_TEXT, LM_ERROR, TAO_Stub::profile_in_use(), TAO_debug_level, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00323 {
00324   TAO_OBJECT_IOR_EVALUATE_RETURN;
00325 
00326   if (this->_stubobj () && this->_stubobj ()->profile_in_use ())
00327     return this->_stubobj ()->profile_in_use ()->_key ();
00328 
00329   if (TAO_debug_level > 2)
00330     {
00331       ACE_ERROR ((LM_ERROR,
00332                   ACE_TEXT ("TAO (%P|%t) Null object key return from ")
00333                   ACE_TEXT ("profile in use\n")));
00334     }
00335 
00336   throw ::CORBA::INTERNAL (
00337     CORBA::SystemException::_tao_minor_code (
00338       0,
00339       EINVAL),
00340     CORBA::COMPLETED_NO);
00341 }

ACE_INLINE CORBA::Object_ptr CORBA::Object::_narrow (  CORBA::Object_ptr  obj  )  [static]
 

No-op it is just here to simplify some templates.

Reimplemented in CORBA::LocalObject, and CORBA::Policy.

Definition at line 69 of file Object.inl.

References _duplicate(), and CORBA::Object_ptr. 

00070 {
00071   return CORBA::Object::_duplicate (obj);
00072 }

ACE_INLINE CORBA::Object_ptr CORBA::Object::_nil (  void   )  [static]
 

Return a NULL object.

Reimplemented in CORBA::LocalObject, and CORBA::Policy.

Definition at line 62 of file Object.inl.

Referenced by _set_policy_overrides(), TAO_Object_Ref_Table::find(), TAO_ORB_Core::implrepo_service(), CORBA::ORB::ior_string_to_object(), TAO_CORBALOC_Parser::make_stub_from_mprofile(), TAO::Objref_Traits< CORBA::Object >::nil(), operator>>(), TAO_FILE_Parser::parse_string(), TAO_CORBANAME_Parser::parse_string(), CORBA::ORB::resolve_policy_current(), CORBA::ORB::resolve_policy_manager(), TAO_ORB_Core::resolve_rir(), TAO_ORB_Core::root_poa(), TAO_ORB_Core::shutdown(), and CORBA::ORB::url_ior_string_to_object(). 

00063 {
00064   return 0;
00065 }

CORBA::Boolean CORBA::Object::_non_existent (  void   )  [virtual]
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 474 of file Object.cpp.

References TAO::Object_Proxy_Broker::_non_existent(), proxy_broker(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00475 {
00476   TAO_OBJECT_IOR_EVALUATE_RETURN;
00477 
00478   CORBA::Boolean retval = false;
00479 
00480   try
00481     {
00482       retval = this->proxy_broker ()->_non_existent (this);
00483     }
00484   catch (const ::CORBA::OBJECT_NOT_EXIST&)
00485     {
00486       retval = true;
00487     }
00488 
00489   return retval;
00490 }

void CORBA::Object::_proxy_broker (  TAO::Object_Proxy_Broker *  proxy_broker  )  [virtual]
 

Set the proxy broker.

Definition at line 344 of file Object.cpp.

References TAO_Stub::object_proxy_broker(), and protocol_proxy_. 

00345 {
00346   this->protocol_proxy_->object_proxy_broker (proxy_broker);
00347 }

void CORBA::Object::_remove_ref (  void   )  [virtual]
 

Decrement the reference count.

Reimplemented in CORBA::LocalObject, and TAO_Local_RefCounted_Object.

Definition at line 123 of file Object.cpp.

References _tao_actual_remove_ref(), and is_local_.

Referenced by CORBA::release(). 

00124 {
00125   if (this->is_local_)
00126     return;
00127 
00128   this->_tao_actual_remove_ref ();
00129 }

char * CORBA::Object::_repository_id (  void   )  [virtual]
 

Get the repository id.

Reimplemented in CORBA::LocalObject.

Definition at line 516 of file Object.cpp.

References TAO::Object_Proxy_Broker::_repository_id(), proxy_broker(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00517 {
00518   TAO_OBJECT_IOR_EVALUATE_RETURN;
00519   return this->proxy_broker ()->_repository_id (this);
00520 }

CORBA::Request_ptr CORBA::Object::_request (  const char *  operation  )  [virtual]
 

DII operation to create a request.

Reimplemented in CORBA::LocalObject.

Definition at line 448 of file Object.cpp.

References ACE_Dynamic_Service< TYPE >::instance(), protocol_proxy_, TAO_Dynamic_Adapter::request(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00449 {
00450   TAO_OBJECT_IOR_EVALUATE_RETURN;
00451   if (this->protocol_proxy_)
00452     {
00453       TAO_Dynamic_Adapter *dynamic_adapter =
00454         ACE_Dynamic_Service<TAO_Dynamic_Adapter>::instance (
00455             TAO_ORB_Core::dynamic_adapter_name ()
00456           );
00457 
00458       return dynamic_adapter->request (
00459                                   this,
00460                                   this->protocol_proxy_->orb_core ()->orb (),
00461                                   operation);
00462     }
00463   else
00464     {
00465       throw ::CORBA::NO_IMPLEMENT ();
00466     }
00467 }

TAO_Abstract_ServantBase * CORBA::Object::_servant (  void   )  const [virtual]
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 192 of file Object.cpp.

References TAO_Stub::collocated_servant(), and protocol_proxy_.

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

00193 {
00194   if (this->protocol_proxy_ == 0)
00195     {
00196       // No stub set. Should not happen.
00197       return 0;
00198     }
00199 
00200   return this->protocol_proxy_->collocated_servant ();
00201 }

CORBA::Object_ptr CORBA::Object::_set_policy_overrides (  const CORBA::PolicyList &  policies,
CORBA::SetOverrideType  set_add
) 
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 555 of file Object.cpp.

References _nil(), ACE_NEW_THROW_EX, CORBA::Object_ptr, orb_core(), CORBA::PolicyList, protocol_proxy_, TAO_ORB_Core::reinitialize_object(), TAO_Stub_Auto_Ptr::release(), TAO_Stub::set_policy_overrides(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00558 {
00559   TAO_OBJECT_IOR_EVALUATE_RETURN;
00560 
00561   if (!this->protocol_proxy_)
00562     throw ::CORBA::NO_IMPLEMENT ();
00563 
00564   TAO_Stub* stub =
00565     this->protocol_proxy_->set_policy_overrides (policies, set_add);
00566 
00567   TAO_Stub_Auto_Ptr safe_stub (stub);
00568 
00569   CORBA::Object_ptr obj = CORBA::Object::_nil ();
00570 
00571   ACE_NEW_THROW_EX (obj,
00572                     CORBA::Object (stub,
00573                                   this->_is_collocated ()),
00574                     CORBA::NO_MEMORY (
00575                       CORBA::SystemException::_tao_minor_code (
00576                         0,
00577                         ENOMEM),
00578                       CORBA::COMPLETED_MAYBE));
00579 
00580   // If the stub is collocated and we don't have a collocated server we need
00581   // to reinitialize it to get it.
00582   if (stub->is_collocated () && stub->collocated_servant () == 0)
00583     {
00584       obj->orb_core ()->reinitialize_object (stub);
00585     }
00586 
00587   (void) safe_stub.release ();
00588 
00589   return obj;
00590 }

TAO_Stub * CORBA::Object::_stubobj (  void   )  [virtual]
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 275 of file Object.cpp.

References protocol_proxy_, and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00276 {
00277   TAO_OBJECT_IOR_EVALUATE_RETURN;
00278   return this->protocol_proxy_;
00279 }

TAO_Stub * CORBA::Object::_stubobj (  void   )  const [virtual]
 

Get the underlying stub object.

Definition at line 269 of file Object.cpp.

References protocol_proxy_.

Referenced by _is_a(), _key(), TAO_ORB_Core::collocation_strategy(), TAO::Invocation_Adapter::get_stub(), TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::Collocated_Invocation::invoke(), TAO_Stub::is_equivalent(), CORBA::ORB::object_to_string(), operator<<(), TAO_ServerRequest::TAO_ServerRequest(), and TAO::Narrow_Utils< T >::unchecked_narrow(). 

00270 {
00271   return this->protocol_proxy_;
00272 }

ACE_INLINE void CORBA::Object::_tao_actual_add_ref (  void   )  [protected]
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 99 of file Object.inl.

References TAO_Configurable_Refcount::increment().

Referenced by _add_ref(), and TAO_Local_RefCounted_Object::_add_ref(). 

00100 {
00101   this->refcount_.increment ();
00102 }

ACE_INLINE void CORBA::Object::_tao_actual_remove_ref (  void   )  [protected]
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 105 of file Object.inl.

References TAO_Configurable_Refcount::decrement().

Referenced by _remove_ref(), and TAO_Local_RefCounted_Object::_remove_ref(). 

00106 {
00107   if (this->refcount_.decrement () != 0)
00108     return;
00109 
00110   delete this;
00111 }

void CORBA::Object::_tao_any_destructor (  void *   )  [static]
 

Used in the implementation of CORBA::Any.

Reimplemented in CORBA::Policy.

Definition at line 132 of file Object.cpp.

References CORBA::Object_ptr. 

00133 {
00134   CORBA::Object_ptr tmp = static_cast<CORBA::Object_ptr> (x);
00135   ::CORBA::release (tmp);
00136 }

CORBA::Boolean CORBA::Object::_validate_connection (  CORBA::PolicyList_out  inconsistent_policies  ) 
 

Determine if we are of the type specified by the "logical_type_id".

Reimplemented in CORBA::LocalObject.

Definition at line 603 of file Object.cpp.

References _is_collocated(), TAO::Object_Proxy_Broker::_non_existent(), TAO::LocateRequest_Invocation_Adapter::get_inconsistent_policies(), TAO::LocateRequest_Invocation_Adapter::invoke(), proxy_broker(), and TAO_OBJECT_IOR_EVALUATE_RETURN. 

00605 {
00606   TAO_OBJECT_IOR_EVALUATE_RETURN;
00607 
00608   inconsistent_policies = 0;
00609   CORBA::Boolean retval = true;
00610 
00611 #if (TAO_HAS_MINIMUM_CORBA == 0)
00612   // Note that the OBJECT_NOT_EXIST exception should be propagated to
00613   // the caller rather than return false, which is why we do not use
00614   // CORBA::Object::_non_existent().  This behavior is consistent
00615   // with the non-collocated case.
00616   if (this->_is_collocated ())
00617       return !(this->proxy_broker ()->_non_existent (this));
00618 
00619   TAO::LocateRequest_Invocation_Adapter tao_call (this);
00620   try
00621     {
00622       tao_call.invoke ();
00623     }
00624   catch (const ::CORBA::INV_POLICY&)
00625     {
00626       inconsistent_policies = tao_call.get_inconsistent_policies ();
00627       retval = false;
00628     }
00629 #else
00630   retval = false;
00631 #endif /* TAO_HAS_MINIMUM_CORBA */
00632 
00633   return retval;
00634 }

bool CORBA::Object::can_convert_to_ior (  void   )  const [virtual]
 

Can this object be stringified?

Definition at line 179 of file Object.cpp.

References _is_local().

Referenced by CORBA::ORB::object_to_string(). 

00180 {
00181   // By default, objects can not be stringified if they are local
00182   return !this->_is_local ();
00183 }

char * CORBA::Object::convert_to_ior (  bool  use_omg_ior_format,
const char *  ior_prefix
)  const [virtual]
 

A hook to allow users to provide custom object stringification.

Note:
This method is intended to be used by classes that implement Smart Proxies and no others.

Definition at line 186 of file Object.cpp.

Referenced by CORBA::ORB::object_to_string(). 

00187 {
00188   return 0;
00189 }

ACE_INLINE const IOP::IOR & CORBA::Object::ior (  void   )  const
 

Accessor for the cached servant reference held on the stub if this object is collocated

Definition at line 93 of file Object.inl.

References ior_.

Referenced by is_nil_i(), and operator<<(). 

00094 {
00095   return this->ior_.in ();
00096 }

ACE_INLINE CORBA::Boolean CORBA::Object::is_evaluated (  void   )  const
 

Accessor to the flag..

Definition at line 75 of file Object.inl.

References is_evaluated_.

Referenced by CORBA::Policy::copy(), CORBA::Policy::destroy(), is_nil_i(), TAO::Narrow_Utils< T >::lazy_evaluation(), and operator<<(). 

00076 {
00077   return this->is_evaluated_;
00078 }

CORBA::Boolean CORBA::Object::is_nil_i (  CORBA::Object_ptr  obj  )  [static]
 

Uninlined part of the now-inlined CORBA::is_nil().

Definition at line 350 of file Object.cpp.

References ior(), is_evaluated(), TAO_ORB_Core::object_is_nil(), CORBA::Object_ptr, orb_core_, and IOP::IOR::profiles.

Referenced by CORBA::is_nil(). 

00351 {
00352   // If the profile length is zero for a non-evaluted IOR it is a
00353   // null-object.
00354   if ((!obj->is_evaluated ()) && obj->ior ().profiles.length () == 0)
00355     return true;
00356 
00357   // To accomodate new definitions.
00358   if (obj->orb_core_)
00359     {
00360       return obj->orb_core_->object_is_nil (obj);
00361     }
00362 
00363   return false;
00364 }

CORBA::Boolean CORBA::Object::marshal (  TAO_OutputCDR &  cdr  )  [virtual]
 

Allows us to forbid marshaling of local interfaces.

Reimplemented in CORBA::Policy.

Definition at line 140 of file Object.cpp. 

00141 {
00142   return (cdr << this);
00143 }

CORBA::Boolean CORBA::Object::marshal (  const Object_ptr  x,
TAO_OutputCDR &  cdr
)  [static]
 

Marshalling operator used by the stub code. A long story why the stub code uses this, let us keep it short here.

Definition at line 146 of file Object.cpp.

References ACE_OutputCDR::good_bit(), CORBA::Object_ptr, ACE_OutputCDR::write_char(), and ACE_OutputCDR::write_ulong().

Referenced by TAO::Objref_Traits< CORBA::Object >::marshal(). 

00148 {
00149   if (x == 0)
00150     {
00151       // NIL objrefs ... marshal as empty type hint, no elements.
00152       cdr.write_ulong (1);
00153       cdr.write_char ('\0');
00154       cdr.write_ulong (0);
00155       return (CORBA::Boolean) cdr.good_bit ();
00156     }
00157 
00158   return x->marshal (cdr);
00159 }

Object& CORBA::Object::operator= (  const Object &   )  [private]
 

ACE_INLINE TAO_ORB_Core * CORBA::Object::orb_core (  void   )  const
 

Accessor for the ORB_Core..

Definition at line 81 of file Object.inl.

Referenced by _set_policy_overrides(), TAO::LocateRequest_Invocation_Adapter::get_timeout(), TAO::Invocation_Adapter::get_timeout(), and TAO::Narrow_Utils< T >::lazy_evaluation(). 

00082 {
00083   return this->orb_core_;
00084 }

TAO::Object_Proxy_Broker * CORBA::Object::proxy_broker (   )  const [protected]
 

Convenience accessor for the object proxy broker of the underlying stub.

Definition at line 657 of file Object.cpp.

References TAO_Stub::object_proxy_broker(), protocol_proxy_, and the_tao_remote_object_proxy_broker().

Referenced by _get_component(), _get_interface(), _is_a(), _non_existent(), _repository_id(), and _validate_connection(). 

00658 {
00659   // Paranoid check. We *should* never access the proxy_broker
00660   // when the object has not been initialised so there *should*
00661   // alway be a stub, but just in case...
00662 
00663   if (this->protocol_proxy_)
00664     {
00665       return this->protocol_proxy_->object_proxy_broker ();
00666     }
00667 
00668   // We have no stub. We cannot be collocated.
00669   return the_tao_remote_object_proxy_broker ();
00670 }

void CORBA::Object::set_collocated_servant (  TAO_Abstract_ServantBase *   ) 
 

Mutator for setting the servant in collocated cases.

This is used by the Object_Adapter to set the servant for collocated cases and only when the object is initialized. The object initialization takes place when IOR's are lazily evaluated.

Definition at line 256 of file Object.cpp.

References TAO_Stub::collocated_servant(), TAO_Stub::is_collocated(), and protocol_proxy_. 

00257 {
00258   this->protocol_proxy_->collocated_servant (b);
00259   this->protocol_proxy_->is_collocated (true);
00260 }

ACE_INLINE IOP::IOR * CORBA::Object::steal_ior (  void   ) 
 

Accessors for the underlying IOP::IOR's.

The steal_ior () call basically relinquishes the ownership of the IOR. This is useful for cases when one wants to initialize a new CORBA Object

Definition at line 87 of file Object.inl.

References ior_.

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

00088 {
00089   return this->ior_._retn ();
00090 }

void CORBA::Object::tao_object_initialize (  Object *   )  [static]
 

Helper function for reading contents of an IOR.

Definition at line 705 of file Object.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT, TAO_ORB_Core::connector_registry(), TAO_Connector_Registry::create_profile(), TAO_ORB_Core::create_stub(), TAO_Stub_Auto_Ptr::get(), TAO_MProfile::give_profile(), TAO_ORB_Core::initialize_object(), TAO_ORB_Core::input_cdr_buffer_allocator(), TAO_ORB_Core::input_cdr_dblock_allocator(), TAO_ORB_Core::input_cdr_msgblock_allocator(), ior_, is_evaluated_, LM_ERROR, LM_WARNING, orb_core_, TAO_MProfile::profile_count(), protocol_proxy_, TAO_Stub_Auto_Ptr::release(), TAO_debug_level, and TAO_ORB_Core_instance(). 

00706 {
00707   CORBA::ULong const profile_count =
00708     obj->ior_->profiles.length ();
00709 
00710   // Assumption is that after calling this method, folks should test
00711   // for protocol_proxy_ or whatever to make sure that things have
00712   // been initialized!
00713   if (profile_count == 0)
00714     return;
00715 
00716   // get a profile container to store all profiles in the IOR.
00717   TAO_MProfile mp (profile_count);
00718 
00719   TAO_ORB_Core *&orb_core = obj->orb_core_;
00720   if (orb_core == 0)
00721     {
00722       orb_core = TAO_ORB_Core_instance ();
00723       if (TAO_debug_level > 0)
00724         {
00725           ACE_DEBUG ((LM_WARNING,
00726                       ACE_TEXT ("TAO (%P|%t) - Object::tao_object_initialize ")
00727                       ACE_TEXT ("WARNING: extracting object from ")
00728                       ACE_TEXT ("default ORB_Core\n")));
00729         }
00730     }
00731 
00732   TAO_Stub *objdata = 0;
00733 
00734   try
00735     {
00736       TAO_Connector_Registry *connector_registry =
00737         orb_core->connector_registry ();
00738 
00739       for (CORBA::ULong i = 0; i != profile_count; ++i)
00740         {
00741           IOP::TaggedProfile &tpfile = obj->ior_->profiles[i];
00742 
00743           // NOTE: This is a place for optimizations. Here we have an
00744           // 2 allocations and 2 copies. Future optimizations should
00745           // target this place.
00746           TAO_OutputCDR o_cdr;
00747 
00748           o_cdr << tpfile;
00749 
00750           TAO_InputCDR cdr (o_cdr,
00751                             orb_core->input_cdr_buffer_allocator (),
00752                             orb_core->input_cdr_dblock_allocator (),
00753                             orb_core->input_cdr_msgblock_allocator (),
00754                             orb_core);
00755 
00756           TAO_Profile *pfile = connector_registry->create_profile (cdr);
00757 
00758           if (pfile != 0)
00759             mp.give_profile (pfile);
00760         }
00761 
00762       // Make sure we got some profiles!
00763       if (mp.profile_count () != profile_count)
00764         {
00765           // @@ This occurs when profile creation fails when decoding the
00766           //    profile from the IOR.
00767           ACE_ERROR ((LM_ERROR,
00768                       ACE_TEXT ("TAO (%P|%t) ERROR: XXXXX Could not create all ")
00769                       ACE_TEXT ("profiles while extracting object\n")
00770                       ACE_TEXT ("TAO (%P|%t) ERROR: reference from the ")
00771                       ACE_TEXT ("CDR stream.\n")));
00772         }
00773 
00774 
00775       objdata = orb_core->create_stub (obj->ior_->type_id.in (), mp);
00776     }
00777   catch (const ::CORBA::Exception& ex)
00778     {
00779       if (TAO_debug_level > 0)
00780         ex._tao_print_exception (
00781           ACE_TEXT ("TAO - ERROR creating stub ")
00782           ACE_TEXT ("object when demarshaling object ")
00783           ACE_TEXT ("reference."));
00784 
00785       return;
00786     }
00787 
00788   TAO_Stub_Auto_Ptr safe_objdata (objdata);
00789 
00790   // This call will set the stub proxy broker if necessary
00791   if (orb_core->initialize_object (safe_objdata.get (), obj) == -1)
00792     return;
00793 
00794   obj->protocol_proxy_ = objdata;
00795 
00796   obj->is_evaluated_ = true;
00797 
00798   // Release the contents of the ior to keep memory consumption down.
00799   obj->ior_ = 0;
00800 
00801   // Transfer ownership to the CORBA::Object
00802   (void) safe_objdata.release ();
00803   return;
00804 }

Member Data Documentation

IOP::IOR_var CORBA::Object::ior_ [private]
 

If the IOR hasnt been evaluated fully, then the contents of the IOR that we received should be in here!

Definition at line 386 of file Object.h.

Referenced by ior(), steal_ior(), and tao_object_initialize().

CORBA::Boolean CORBA::Object::is_evaluated_ [private]
 

Flag to indicate whether the IOP::IOR has been evaluated fully.

Definition at line 382 of file Object.h.

Referenced by is_evaluated(), and tao_object_initialize().

CORBA::Boolean CORBA::Object::is_local_ [private]
 

Specify whether this is a local object or not.

Definition at line 379 of file Object.h.

Referenced by _add_ref(), _is_local(), and _remove_ref().

ACE_Lock* CORBA::Object::object_init_lock_ [private]
 

Protect reference count manipulation from race conditions.

This lock is only instantiated for unconstrained objects. The reason for this is that locality-constrained objects that do not require reference counting (the default) may be instantiated in the critical path.

Definition at line 418 of file Object.h.

Referenced by Object(), and ~Object().

TAO_ORB_Core* CORBA::Object::orb_core_ [private]
 

Cached pointer of our ORB_Core.

Be aware that this pointer can be zero or not. In fact there are two ways to get this pointer filled:

  • If CORBA::Object is constructed through one of the constructors with a stub and null ORB_Core, we use the orb_core from the stub to fill this pointer
  • If the other constructor, which uses IOP::IOR is used, a stub needs to be created first (i.e., the IOR needs to be evaluated first), in which case the ORB_Core would be null. The orb_core pointer then needs to be accessed from the stub and passed back as part of _get_orb().

Definition at line 401 of file Object.h.

Referenced by is_nil_i(), and tao_object_initialize().

TAO_Stub* CORBA::Object::protocol_proxy_ [private]
 

Pointer to the protocol-specific "object" containing important profiling information regarding this proxy. The protocol proxy is (potentially) shared among several Objects

Definition at line 409 of file Object.h.

Referenced by _create_request(), _get_cached_policy(), _get_orb(), _get_policy(), _get_policy_overrides(), _hash(), _is_a(), _is_collocated(), _is_equivalent(), _proxy_broker(), _request(), _servant(), _set_policy_overrides(), _stubobj(), Object(), proxy_broker(), set_collocated_servant(), tao_object_initialize(), and ~Object().

TAO_Configurable_Refcount CORBA::Object::refcount_ [protected]
 

Number of outstanding references to this object.

Definition at line 368 of file Object.h.

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 13:17:19 2008 for TAO by doxygen 1.3.6