TAO_Connection_Handler Class Reference

TAO_Connection_Handler. More...

#include <Connection_Handler.h>

Inheritance diagram for TAO_Connection_Handler:

Inheritance graph
[legend]
Collaboration diagram for TAO_Connection_Handler:

Collaboration graph
[legend]

List of all members.

Public Member Functions

 TAO_Connection_Handler (void)
 Constructor.
 TAO_Connection_Handler (TAO_ORB_Core *orb_core)
 Constructor.
virtual ~TAO_Connection_Handler (void)
 Destructor.
TAO_Transporttransport (void)
 Return the underlying transport object.
void transport (TAO_Transport *transport)
 Set the underlying transport object.
bool is_closed (void) const
 Is the handler closed or timed out?
bool is_open (void) const
 Is the handler open?
bool is_timeout (void) const
 Closed due to timeout?
bool is_connecting (void) const
 Is the handler in the process of being connected?
virtual int close_connection (void)=0
 Close the underlying connection.
virtual int handle_input (ACE_HANDLE fd)=0
int svc_i (void)
virtual int open_handler (void *)=0
 A open () hook.
virtual int close_handler (u_long flags=0)
void connection_pending (void)
void cancel_pending_connection (void)
virtual int set_dscp_codepoint (CORBA::Boolean set_network_priority)
virtual int set_dscp_codepoint (CORBA::Long dscp_codepoint)
virtual int release_os_resources (void)
 Release the OS resources related to this handler.
virtual int handle_write_ready (const ACE_Time_Value *timeout)

Protected Member Functions

TAO_ORB_Coreorb_core (void)
 Return our TAO_ORB_Core pointer.
int shared_open (void)
int set_socket_option (ACE_SOCK &sock, int snd_size, int rcv_size)
 Set options on the socket.
Helper methods for Event_Handler-based derived classes.
Many (actually all so far) implementations of TAO_Connection_Handler are a mixin of TAO_Connection_Handler and some form of ACE_Event_Handler. The following methods simplify such implementations by capturing the common code in a single place.

int handle_output_eh (ACE_HANDLE h, ACE_Event_Handler *eh)
 Implement the handle_output() callback.
int handle_input_eh (ACE_HANDLE h, ACE_Event_Handler *eh)
 Implement the handle_input() callback.
int handle_input_internal (ACE_HANDLE h, ACE_Event_Handler *eh)
 Implement the handle_output() callback.
int close_connection_eh (ACE_Event_Handler *eh)
virtual void pre_io_hook (int &return_value)
virtual void pos_io_hook (int &return_value)

Private Member Functions

void operator= (const TAO_Connection_Handler &)
 TAO_Connection_Handler (const TAO_Connection_Handler &)

Private Attributes

TAO_ORB_Core *const orb_core_
 Pointer to the TAO_ORB_Core.
TAO_Transporttransport_
 Transport object reference.
ACE_Locklock_
bool connection_pending_
 Stores the connection pending state.
bool is_closed_


Detailed Description

TAO_Connection_Handler.

This class is an abstraction for the connection handlers. The connections handler in every protocol can derive from this class as well as the ACE_Svc_Handler specialised for the right protocol. This way, most of the common code for the different protocols would be in this implementation.


Constructor & Destructor Documentation

TAO_Connection_Handler::TAO_Connection_Handler ( void   ) 

Constructor.

TAO_Connection_Handler::TAO_Connection_Handler ( TAO_ORB_Core orb_core  ) 

Constructor.

TAO_Connection_Handler::~TAO_Connection_Handler ( void   )  [virtual]

Destructor.

TAO_Connection_Handler::TAO_Connection_Handler ( const TAO_Connection_Handler  )  [private]


Member Function Documentation

void TAO_Connection_Handler::cancel_pending_connection ( void   )  [inline]

A pending connection may be canceled due to an error detected while the initiating thread is still in the Connector.

virtual int TAO_Connection_Handler::close_connection ( void   )  [pure virtual]

Close the underlying connection.

Used by the ORB to actively close connections that are idle, stale or somehow are determined to be broken before the Reactor does.

Returns:
Return 0 if the connection was already closed, non-zero otherwise.

Implemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::close_connection_eh ( ACE_Event_Handler eh  )  [protected]

Implement close_connection() for Connection_Handlers that are also Event_Handlers.

int TAO_Connection_Handler::close_handler ( u_long  flags = 0  )  [virtual]

A close() hook, called by the Transport Connector when they want to close this handler

void TAO_Connection_Handler::connection_pending ( void   )  [inline]

When waiting for an asynchronous connection to complete an additional reference must be maintained, related to bugzilla #2417. However once the connection is successfully established, this reference must be removed. Using connection_pending allows the connection handler to know that it is opening as a result of a delayed asynch connection rather than an immediate synch connection, which has no additional reference needs.

virtual int TAO_Connection_Handler::handle_input ( ACE_HANDLE  fd  )  [pure virtual]

The event handler calls, here so that other objects who hold a reference to this object can call the event handler methods.

Implemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::handle_input_eh ( ACE_HANDLE  h,
ACE_Event_Handler eh 
) [protected]

Implement the handle_input() callback.

int TAO_Connection_Handler::handle_input_internal ( ACE_HANDLE  h,
ACE_Event_Handler eh 
) [protected]

Implement the handle_output() callback.

int TAO_Connection_Handler::handle_output_eh ( ACE_HANDLE  h,
ACE_Event_Handler eh 
) [protected]

Implement the handle_output() callback.

int TAO_Connection_Handler::handle_write_ready ( const ACE_Time_Value timeout  )  [inline, virtual]

Derived classes should implement this for proper support with the Blocking Flushing Strategy.

Reimplemented in TAO_IIOP_Connection_Handler.

bool TAO_Connection_Handler::is_closed ( void   )  const [inline]

Is the handler closed or timed out?

bool TAO_Connection_Handler::is_connecting ( void   )  const [inline]

Is the handler in the process of being connected?

bool TAO_Connection_Handler::is_open ( void   )  const [inline]

Is the handler open?

bool TAO_Connection_Handler::is_timeout ( void   )  const [inline]

Closed due to timeout?

virtual int TAO_Connection_Handler::open_handler ( void *   )  [pure virtual]

A open () hook.

See Thread_Per_Connection_Handler for a use case

Implemented in TAO_IIOP_Connection_Handler.

void TAO_Connection_Handler::operator= ( const TAO_Connection_Handler  )  [private]

TAO_ORB_Core * TAO_Connection_Handler::orb_core ( void   )  [inline, protected]

Return our TAO_ORB_Core pointer.

void TAO_Connection_Handler::pos_io_hook ( int &  return_value  )  [protected, virtual]

Post-invocation hook for I/O operations (handle_input() & handle_output()) See the SSLIOP protocol for an interesting use-case

void TAO_Connection_Handler::pre_io_hook ( int &  return_value  )  [protected, virtual]

Pre-invocation hook for I/O operations (handle_input() & handle_output()) See the SSLIOP protocol for an interesting use-case

int TAO_Connection_Handler::release_os_resources ( void   )  [virtual]

Release the OS resources related to this handler.

Reimplemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::set_dscp_codepoint ( CORBA::Long  dscp_codepoint  )  [virtual]

Reimplemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::set_dscp_codepoint ( CORBA::Boolean  set_network_priority  )  [virtual]

Set the Diff-Serv codepoint on outgoing packets. Only has effect for remote protocols (e.g., IIOP); no effect for local protocols (UIOP). Default implementation is for local protocols. Remote protocols must overwrite implementation.

Reimplemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::set_socket_option ( ACE_SOCK sock,
int  snd_size,
int  rcv_size 
) [protected]

Set options on the socket.

int TAO_Connection_Handler::shared_open ( void   )  [protected]

A common function called at the start of any protocol-specific open. Returns -1 on a failure (although no failure mode is currently defined).

int TAO_Connection_Handler::svc_i ( void   ) 

This method is invoked from the svc () method of the Svc_Handler Object.

void TAO_Connection_Handler::transport ( TAO_Transport transport  ) 

Set the underlying transport object.

TAO_Transport * TAO_Connection_Handler::transport ( void   )  [inline]

Return the underlying transport object.


Member Data Documentation

Stores the connection pending state.

Once closed make sure the transport is not added back to the cache. This is distinct from the leader-follower state so it cannot be reset.

Internal state lock, needs to be separate from the reference count / pending upcalls lock because they interleave.

Pointer to the TAO_ORB_Core.

Transport object reference.


The documentation for this class was generated from the following files:

Generated on Mon Jul 13 16:25:44 2009 for TAO by  doxygen 1.5.8