#include <Connection_Handler.h>

Inheritance diagram for TAO_Connection_Handler:

Collaboration diagram for TAO_Connection_Handler:

Public Member Functions
	TAO_Connection_Handler (TAO_ORB_Core *orb_core)
	Constructor.
virtual	~TAO_Connection_Handler (void)
	Destructor.
TAO_Transport *	transport (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_Core *	orb_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 Attributes
TAO_ORB_Core *const	orb_core_
	Pointer to the TAO_ORB_Core.
TAO_Transport *	transport_
	Transport object reference.
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 ( TAO_ORB_Core * orb_core ) [explicit]

Constructor.

TAO_Connection_Handler::~TAO_Connection_Handler ( void ) [virtual]

Destructor.

Member Function Documentation

void TAO_Connection_Handler::cancel_pending_connection ( void )

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 )

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 ) [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

Is the handler closed or timed out?

bool TAO_Connection_Handler::is_connecting ( void ) const

Is the handler in the process of being connected?

bool TAO_Connection_Handler::is_open ( void ) const

Is the handler open?

bool TAO_Connection_Handler::is_timeout ( void ) const

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.

TAO_ORB_Core * TAO_Connection_Handler::orb_core ( void ) [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::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_dscp_codepoint ( CORBA::Long dscp_codepoint ) [virtual]

Reimplemented in TAO_IIOP_Connection_Handler.