#include <Transport_Connector.h>
Public Member Functions | |
TAO_Connector (CORBA::ULong tag) | |
Default constructor. | |
virtual | ~TAO_Connector (void) |
The destructor. | |
CORBA::ULong | tag (void) const |
int | make_mprofile (const char *ior, TAO_MProfile &mprofile) |
virtual TAO_Profile * | corbaloc_scan (const char *ior, size_t &len) |
virtual int | open (TAO_ORB_Core *orb_core)=0 |
Initialize object and register with reactor. | |
virtual int | close (void)=0 |
Shutdown Connector bridge and concrete Connector. | |
virtual TAO_Transport * | connect (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface *desc, ACE_Time_Value *timeout) |
virtual TAO_Transport * | parallel_connect (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface *desc, ACE_Time_Value *timeout) |
virtual TAO_Profile * | create_profile (TAO_InputCDR &cdr)=0 |
virtual int | check_prefix (const char *endpoint)=0 |
virtual char | object_key_delimiter (void) const =0 |
Return the object key delimiter to use or expect. | |
Protected Member Functions | |
virtual int | supports_parallel_connects (void) const |
virtual TAO_Profile * | make_profile (void)=0 |
Create a profile with a given endpoint. | |
virtual int | set_validate_endpoint (TAO_Endpoint *endpoint)=0 |
virtual TAO_Transport * | make_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout)=0 |
Make a connection. | |
virtual TAO_Transport * | make_parallel_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout) |
virtual int | cancel_svc_handler (TAO_Connection_Handler *svc_handler)=0 |
Cancel the passed cvs handler from the connector. | |
virtual int | check_connection_closure (TAO_Connection_Handler *connection_handler) |
Check whether the connection is not closed. | |
virtual bool | wait_for_connection_completion (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, TAO_Transport *&transport, ACE_Time_Value *timeout) |
virtual bool | wait_for_connection_completion (TAO::Profile_Transport_Resolver *r, TAO_Transport *&the_winner, TAO_Transport **transport, unsigned int count, TAO_LF_Multi_Event *mev, ACE_Time_Value *timeout) |
bool | new_connection_is_ok (size_t busy_count) |
See if a new connection is allowed. | |
bool | wait_for_transport (TAO::Profile_Transport_Resolver *r, TAO_Transport *base_transport, ACE_Time_Value *timeout, bool force_wait) |
void | orb_core (TAO_ORB_Core *orb_core) |
Set the ORB Core pointer. | |
int | create_connect_strategy (void) |
Create a connect strategy. | |
TAO_ORB_Core * | orb_core (void) |
Return the TAO_ORB_Core pointer. | |
Protected Attributes | |
TAO_Connect_Strategy * | active_connect_strategy_ |
The (a)synch connect strategy. | |
Private Attributes | |
CORBA::ULong const | tag_ |
IOP protocol tag. | |
TAO_ORB_Core * | orb_core_ |
Pointer to our ORB core. |
Base class for connector bridge object.
TAO_Connector::TAO_Connector | ( | CORBA::ULong | tag | ) |
Default constructor.
TAO_Connector::~TAO_Connector | ( | void | ) | [virtual] |
The destructor.
virtual int TAO_Connector::cancel_svc_handler | ( | TAO_Connection_Handler * | svc_handler | ) | [protected, pure virtual] |
int TAO_Connector::check_connection_closure | ( | TAO_Connection_Handler * | connection_handler | ) | [protected, virtual] |
Check whether the connection is not closed.
0 | The connection happens to be not closed, but is now open because an other thread managed to open the handler | |
-1 | The connection is closed |
virtual int TAO_Connector::check_prefix | ( | const char * | endpoint | ) | [pure virtual] |
Check that the prefix of the provided endpoint is valid for use with a given pluggable protocol.
Implemented in TAO_IIOP_Connector.
virtual int TAO_Connector::close | ( | void | ) | [pure virtual] |
TAO_Transport * TAO_Connector::connect | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport_Descriptor_Interface * | desc, | |||
ACE_Time_Value * | timeout | |||
) | [virtual] |
To support pluggable we need to abstract away the details of the connect () method so it can be called from the invocation code independent of the actual transport protocol in use.
TAO_Profile * TAO_Connector::corbaloc_scan | ( | const char * | ior, | |
size_t & | len | |||
) | [virtual] |
Helper function to assist corbaloc parsing. The default simply validates the protocol identifyier and scans up to the next comma or slash. Any protocol that has a specific need, such as uiop, can override this method to provide a custom scanner. The profile returned is either null if this the ior does not match or an empty profile of the correct type, obtained from make_profile().
int TAO_Connector::create_connect_strategy | ( | void | ) | [protected] |
Create a connect strategy.
virtual TAO_Profile* TAO_Connector::create_profile | ( | TAO_InputCDR & | cdr | ) | [pure virtual] |
Create a profile for this protocol and initialize it based on the encapsulation in cdr
Implemented in TAO_IIOP_Connector.
virtual TAO_Transport* TAO_Connector::make_connection | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport_Descriptor_Interface & | desc, | |||
ACE_Time_Value * | timeout | |||
) | [protected, pure virtual] |
int TAO_Connector::make_mprofile | ( | const char * | ior, | |
TAO_MProfile & | mprofile | |||
) |
Parse a string containing a URL style IOR and return an MProfile. Verify that ior is in the correct format.
TAO_Transport * TAO_Connector::make_parallel_connection | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport_Descriptor_Interface & | desc, | |||
ACE_Time_Value * | timeout | |||
) | [protected, virtual] |
Make a connection using - not a pure virtual since not all protocols support this.
Reimplemented in TAO_IIOP_Connector.
virtual TAO_Profile* TAO_Connector::make_profile | ( | void | ) | [protected, pure virtual] |
bool TAO_Connector::new_connection_is_ok | ( | size_t | busy_count | ) | [protected] |
See if a new connection is allowed.
virtual char TAO_Connector::object_key_delimiter | ( | void | ) | const [pure virtual] |
virtual int TAO_Connector::open | ( | TAO_ORB_Core * | orb_core | ) | [pure virtual] |
TAO_ORB_Core * TAO_Connector::orb_core | ( | void | ) | [protected] |
Return the TAO_ORB_Core pointer.
void TAO_Connector::orb_core | ( | TAO_ORB_Core * | orb_core | ) | [protected] |
Set the ORB Core pointer.
TAO_Transport * TAO_Connector::parallel_connect | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport_Descriptor_Interface * | desc, | |||
ACE_Time_Value * | timeout | |||
) | [virtual] |
A variation on connect that will try simultanious connections on all endpoints listed in the desc.
virtual int TAO_Connector::set_validate_endpoint | ( | TAO_Endpoint * | endpoint | ) | [protected, pure virtual] |
Set and validate endpoint. We need to do this to initialize our remote *_Addr's which have not been done during IOR decode.
Implemented in TAO_IIOP_Connector.
int TAO_Connector::supports_parallel_connects | ( | void | ) | const [protected, virtual] |
A flag indicating the actual connector supports parallel connection attempts. The base implementation alwayse returns 0. Override to return non-zero if parallel connection attempts may be tried.
Reimplemented in TAO_IIOP_Connector.
CORBA::ULong TAO_Connector::tag | ( | void | ) | const |
The tag identifying the specific ORB transport layer protocol. For example IOP::TAG_INTERNET_IOP == 0. The tag is used in the IOR to identify the type of profile included. IOR -> {{tag0, profile0} {tag1, profile1} ...}. The IOP module defines the ProfileId typedef to be a CORBA::ULong.
bool TAO_Connector::wait_for_connection_completion | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport *& | the_winner, | |||
TAO_Transport ** | transport, | |||
unsigned int | count, | |||
TAO_LF_Multi_Event * | mev, | |||
ACE_Time_Value * | timeout | |||
) | [protected, virtual] |
In the case of a parallel connection attempt, we take an array of transports, and wait on any of them. When the first one completes, the rest are closed.
bool TAO_Connector::wait_for_connection_completion | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport_Descriptor_Interface & | desc, | |||
TAO_Transport *& | transport, | |||
ACE_Time_Value * | timeout | |||
) | [protected, virtual] |
Wait for connection completion. We have a transport that is not connected yet, wait until it is connected.
true | When we could use transport |
bool TAO_Connector::wait_for_transport | ( | TAO::Profile_Transport_Resolver * | r, | |
TAO_Transport * | base_transport, | |||
ACE_Time_Value * | timeout, | |||
bool | force_wait | |||
) | [protected] |
Wait for a transport to be connected Note: no longer changes transport reference count @ returns true if wait was uneventful @ false if error occurred during wait
The (a)synch connect strategy.
TAO_ORB_Core* TAO_Connector::orb_core_ [private] |
Pointer to our ORB core.
CORBA::ULong const TAO_Connector::tag_ [private] |
IOP protocol tag.