#include <Profile.h>
Inheritance diagram for TAO_Profile:
Public Member Functions | |
TAO_Profile (CORBA::ULong tag, TAO_ORB_Core *orb_core, const TAO_GIOP_Message_Version &version) | |
Constructor. | |
virtual | ~TAO_Profile (void) |
If you have a virtual method you need a virtual dtor. | |
Non virtual methods for the profile classes. | |
CORBA::ULong | tag (void) const |
The tag, each concrete class will have a specific tag value. | |
const TAO_GIOP_Message_Version & | version (void) const |
TAO_ORB_Core * | orb_core (void) const |
Get a pointer to the TAO_ORB_Core. | |
CORBA::ULong | _incr_refcnt (void) |
Increase the reference count by one on this object. | |
CORBA::ULong | _decr_refcnt (void) |
void | forward_to (TAO_MProfile *mprofiles) |
Keep a pointer to the forwarded profile. | |
TAO_MProfile * | forward_to (void) |
MProfile accessor. | |
const TAO_Tagged_Components & | tagged_components (void) const |
TAO_Tagged_Components & | tagged_components (void) |
The tag, each concrete class will have a specific tag value. | |
void | add_tagged_component (const IOP::TaggedComponent &component ACE_ENV_ARG_DECL) |
Add the given tagged component to the profile. | |
CORBA::Short | addressing_mode (void) const |
const TAO::ObjectKey & | object_key (void) const |
TAO::ObjectKey * | _key (void) const |
Template methods that needs to be implemented by the | |
concrete classes. Some of the methods may be overridden only under specila circumstances. | |
virtual int | encode (TAO_OutputCDR &stream) const |
Encode this profile in a stream, i.e. marshal it. | |
virtual int | decode (TAO_InputCDR &cdr) |
Initialize this object using the given CDR octet string. | |
IOP::TaggedProfile * | create_tagged_profile (void) |
virtual void | policies (CORBA::PolicyList *policy_list ACE_ENV_ARG_DECL) |
virtual void | get_policies (CORBA::PolicyList &policy_list ACE_ENV_ARG_DECL) |
Accessor for the client exposed policies of this profile. | |
virtual int | supports_multicast (void) const |
Returns true if this profile can specify multicast endpoints. | |
virtual bool | supports_non_blocking_oneways (void) const |
Returns true if this profile supports non blocking oneways. | |
virtual void | addressing_mode (CORBA::Short addr_mode ACE_ENV_ARG_DECL) |
virtual char | object_key_delimiter (void) const =0 |
The object key delimiter. | |
virtual void | parse_string (const char *string ACE_ENV_ARG_DECL) |
virtual char * | to_string (ACE_ENV_SINGLE_ARG_DECL)=0 |
virtual int | encode_endpoints (void)=0 |
virtual TAO_Endpoint * | endpoint (void)=0 |
virtual CORBA::ULong | endpoint_count (void) const =0 |
Return how many endpoints this profile contains. | |
CORBA::Boolean | is_equivalent (const TAO_Profile *other_profile) |
Verify profile equivalance. | |
virtual CORBA::ULong | hash (CORBA::ULong max ACE_ENV_ARG_DECL)=0 |
Return a hash value for this object. | |
Protected Member Functions | |
TAO_Profile (CORBA::ULong tag, TAO_ORB_Core *orb_core, const TAO::ObjectKey &key, const TAO_GIOP_Message_Version &version) | |
To be used by inherited classes. | |
void | set_tagged_components (TAO_OutputCDR &cdr) |
virtual CORBA::Boolean | do_is_equivalent (const TAO_Profile *other)=0 |
Profile equivalence template method invoked on subclasses. | |
virtual CORBA::Boolean | is_equivalent_hook (const TAO_Profile *other) |
Allow services to apply their own definition of "equivalence.". | |
CORBA::ULong | hash_service_i (CORBA::ULong m) |
Protected template methods. | |
virtual int | decode_profile (TAO_InputCDR &cdr)=0 |
Decode the protocol specific profile details. | |
virtual void | create_profile_body (TAO_OutputCDR &cdr) const =0 |
Creates an encapsulation of the ProfileBody struct in the cdr. | |
virtual int | decode_endpoints (void)=0 |
virtual void | parse_string_i (const char *string ACE_ENV_ARG_DECL)=0 |
Protocol specific implementation of parse_string (). | |
Protected Attributes | |
TAO_GIOP_Message_Version | version_ |
IIOP version number. | |
TAO_Tagged_Components | tagged_components_ |
The tagged components. | |
CORBA::Boolean | are_policies_parsed_ |
CORBA::Short | addressing_mode_ |
IOP::TaggedProfile * | tagged_profile_ |
Our tagged profile. | |
TAO::Refcounted_ObjectKey * | ref_object_key_ |
object_key associated with this profile. | |
Private Member Functions | |
TAO_MProfile * | forward_to_i (void) |
This object keeps ownership of this object. | |
void | verify_orb_configuration (ACE_ENV_SINGLE_ARG_DECL) |
void | verify_profile_version (ACE_ENV_SINGLE_ARG_DECL) |
TAO_Profile (const TAO_Profile &) | |
void | operator= (const TAO_Profile &) |
Private Attributes | |
CORBA::ULong | tag_ |
IOP protocol tag. | |
TAO_ORB_Core * | orb_core_ |
Pointer to the ORB core. | |
TAO_MProfile * | forward_to_ |
ACE_Lock * | refcount_lock_ |
Mutex to protect reference count. | |
CORBA::ULong | refcount_ |
Number of outstanding references to this object. |
An abstract base class for representing object location information. This is based on the CORBA IOR definitions.
|
Constructor.
|
|
If you have a virtual method you need a virtual dtor.
|
|
To be used by inherited classes.
|
|
|
|
Decrement the object's reference count. When this count goes to 0 this object will be deleted. |
|
Increase the reference count by one on this object.
|
|
Obtain the object key, return 0 if the profile cannot be parsed. The memory is owned by the caller! Reimplemented in TAO_Unknown_Profile. |
|
Add the given tagged component to the profile.
|
|
Set the addressing mode if a remote servant replies with an addressing mode exception. If this profile doesn't support a particular addressing mode, this method needs to be overridden signal the appropriate error. ** RACE CONDITION NOTE ** Currently, getting and setting the addressing mode is not protected by a mutex. Theoretically, this could cause a race condition if one thread sends a request, then gets an exception from the remote servant to change the addressing mode, and then another thread sends a different request to the same servant using the wrong addressing mode. The result of this is that we'll get another address change exception. (Annoying, but not that bad.) In practice at the current time, the above theoretical case never happens since the target specification always uses the object key except for MIOP requests. Remote ORBs can't respond to MIOP requests even to send exceptions, so even in this case, the race condition can't happen. Therefore, for the time being, there is no lock to protect the addressing mode. Given that the addressing mode is checked in the critical path, this decision seems like a good thing. |
|
Return the current addressing mode for this profile. In almost all cases, this is TAO_Target_Specification::Key_Addr. |
|
Creates an encapsulation of the ProfileBody struct in the cdr.
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
This method is used to get the IOP::TaggedProfile. The profile information that is received from the server side would have already been decoded. So this method will just make a IOP::TaggedProfile struct from the existing information and return the reference to that. This method is necessary for GIOP 1.2. |
|
Initialize this object using the given CDR octet string.
Reimplemented in TAO_Unknown_Profile. |
|
Helper for <decode>. Decodes endpoints from a tagged component. Decode only if RTCORBA is enabled. Furthermore, we may not find TAO_TAG_ENDPOINTS component, e.g., if we are talking to nonRT version of TAO or some other ORB. This is not an error, and we must proceed. Return 0 on success and -1 on failure. Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Decode the protocol specific profile details.
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Profile equivalence template method invoked on subclasses. TAO_Profile subclasses must implement this template method so that they can apply their own definition of profile equivalence. Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Encode this profile in a stream, i.e. marshal it.
Reimplemented in TAO_Unknown_Profile. |
|
Encodes this profile's endpoints into a tagged component. This is done only if RTCORBA is enabled, since currently this is the only case when we have more than one endpoint per profile. Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Return pointer to this profile's endpoint. If the profile contains more than one endpoint, i.e., a list, the method returns the head of the list. Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Return how many endpoints this profile contains.
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
MProfile accessor.
|
|
Keep a pointer to the forwarded profile.
|
|
This object keeps ownership of this object.
|
|
Accessor for the client exposed policies of this profile.
|
|
Return a hash value for this object.
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
|
|
Verify profile equivalance. Two profiles are equivalent if their tag, object_key, version and all endpoints are the same.
|
|
Allow services to apply their own definition of "equivalence.".
This method differs from the Reimplemented in TAO_Unknown_Profile. |
|
Reimplemented in TAO_Unknown_Profile. |
|
The object key delimiter.
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
|
|
Get a pointer to the TAO_ORB_Core.
|
|
Initialize this object using the given input string. Supports URL style of object references Reimplemented in TAO_Unknown_Profile. |
|
Protocol specific implementation of parse_string ().
Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
This method sets the client exposed policies, i.e., the ones propagated in the IOR, for this profile. |
|
Helper method that encodes the endpoints for RTCORBA as tagged_components. |
|
Returns true if this profile can specify multicast endpoints.
|
|
Returns true if this profile supports non blocking oneways.
|
|
The tag, each concrete class will have a specific tag value.
|
|
The tag, each concrete class will have a specific tag value.
|
|
Access the tagged components, notice that they they could be empty (or ignored) for non-GIOP protocols (and even for GIOP-1.0) |
|
Return a string representation for this profile. Client must deallocate memory. Only one endpoint is included into the string. Implemented in TAO_IIOP_Profile, and TAO_Unknown_Profile. |
|
Verify that the current ORB's configuration supports tagged components in IORs. |
|
Verify that the given profile supports tagged components, i.e. is not a GIOP 1.0 profile. |
|
Return a pointer to this profile's version. This object maintains ownership. |
|
The current addressing mode. This may be changed if a remote server sends back an address mode exception. |
|
Flag indicating whether the lazy decoding of the client exposed policies has taken place. |
|
The TAO_MProfile which contains the profiles for the forwarded object. |
|
Pointer to the ORB core.
|
|
object_key associated with this profile.
|
|
Number of outstanding references to this object.
|
|
Mutex to protect reference count.
|
|
IOP protocol tag.
|
|
The tagged components.
|
|
Our tagged profile.
|
|
IIOP version number.
|