Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACE_Event_Handler_T Class Template Reference

Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lavender@isode.com) for sharing this idea. More...

#include <Event_Handler_T.h>

Inheritance diagram for ACE_Event_Handler_T:

Inheritance graph
[legend]
Collaboration diagram for ACE_Event_Handler_T:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_HANDLE(T::* GET_HANDLE )(void) const
typedef void(T::* SET_HANDLE )(ACE_HANDLE)
typedef int(T::* IO_HANDLER )(ACE_HANDLE)
 Handle I/O events. More...

typedef int(T::* TO_HANDLER )(const ACE_Time_Value &, const void *)
 Handle timeout events. More...

typedef int(T::* CL_HANDLER )(ACE_HANDLE, ACE_Reactor_Mask)
 Handle close events. More...

typedef int(T::* SIG_HANDLER )(ACE_HANDLE, siginfo_t *, ucontext_t *)
 = Initialization and termination methods. More...


Public Methods

 ACE_Event_Handler_T (T *op_handler, int delete_handler, GET_HANDLE get_handle=0, IO_HANDLER input=0, CL_HANDLER close=0, SIG_HANDLER sig=0, TO_HANDLER timeout=0, IO_HANDLER output=0, SET_HANDLE set_handle=0, IO_HANDLER except=0)
 Initialize the op_handler. More...

 ~ACE_Event_Handler_T (void)
 Close down and delete the <op_handler>. More...

virtual ACE_HANDLE get_handle (void) const
 Get the I/O handle. More...

virtual void set_handle (ACE_HANDLE)
 Set the I/O handle. More...

virtual int handle_input (ACE_HANDLE fd=-1)
 Called when input events occur (e.g., connection or data). More...

virtual int handle_output (ACE_HANDLE fd=-1)
 Called when output events are possible (e.g., when flow control abates or non-blocking connection completes). More...

virtual int handle_exception (ACE_HANDLE fd=-1)
 Called when an exceptional events occur (e.g., SIGURG). More...

virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg=0)
virtual int handle_close (ACE_HANDLE fd, ACE_Reactor_Mask close_mask)
 Called when a <handle_*()> method returns -1 or when the <remove_handler> method is called on an <ACE_Reactor>. The <close_mask> indicates which event has triggered the <handle_close> method callback on a particular <handle>. More...

virtual int handle_signal (int signum, siginfo_t *=0, ucontext_t *=0)
 Called when object is signaled by OS (either via UNIX signals or when a Win32 object becomes signaled). More...

T * op_handler (void)
void op_handler (T *)
GET_HANDLE handle_get (void)
void handle_get (GET_HANDLE)
SET_HANDLE handle_set (void)
void handle_set (SET_HANDLE)
IO_HANDLER input_handler (void)
void input_handler (IO_HANDLER)
IO_HANDLER output_handler (void)
void output_handler (IO_HANDLER)
IO_HANDLER except_handler (void)
void except_handler (IO_HANDLER)
TO_HANDLER to_handler (void)
void to_handler (TO_HANDLER)
CL_HANDLER cl_handler (void)
void cl_handler (CL_HANDLER)
SIG_HANDLER sig_handler (void)
void sig_handler (SIG_HANDLER)
void dump (void) const
 Dump the state of an object. More...


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...


Protected Attributes

T * op_handler_
 Pointer to the object that handles all the delegated operations. More...

IO_HANDLER input_handler_
IO_HANDLER output_handler_
IO_HANDLER except_handler_
TO_HANDLER to_handler_
 Handle timeout events. More...

CL_HANDLER cl_handler_
 Handle close events. More...

SIG_HANDLER sig_handler_
 Handle signal events. More...

int delete_handler_
 Keeps track of whether we need to delete the handler in the destructor. More...

SET_HANDLE set_handle_
GET_HANDLE get_handle_

Detailed Description

template<class T>
class ACE_Event_Handler_T< T >

Enable a class that doesn't inherit from the ACE_Event_Handler to be incorporated into the ACE_Reactor framework. Thanks to Greg Lavender (g.lavender@isode.com) for sharing this idea.

It is sometimes the case that an application has a hierarchy of operation dispatcher classes that have their own inheritance hierarchy but also would like to integrate with the ACE_Reactor. Rather than adopt a "mixin" approach, it is often cleaner to define a template as a subclass of ACE_Event_Handler and paramterize it with an operation dispatcher type. When constructing an instantiation of the ACE_Event_Handler_T object, a set of pointers to member functions must be provided so that when one of the handle_* methods is called by the ACE_Reactor, the appropriate method is called on the underlying operations object. This is done since in some cases it is useful to map any event that happens to the same method on an object. The ACE_Event_Handler_T template is instantiated by an operations object and registered with the ACE_Reactor, and it then calls the appropriate op_handler. So, it's basically just another level of indirection in event dispatching. The coupling betweent the ultimate handler of the event and the ACE_Event_Handler class is relaxed a bit by have this intermediate <op_handler_> object of type <T> around. The client object can then dynamically change the bindings for the various handlers so that during the life of one of the operation objects, it can change how it wants events to be handled. It just instantiates a new instance of the template with different bindings and reregisters this new object with the ACE_Reactor.

Definition at line 62 of file Event_Handler_T.h.


Member Typedef Documentation

template<class T>
typedef int(T::* ACE_Event_Handler_T::CL_HANDLER)(ACE_HANDLE, ACE_Reactor_Mask)
 

Handle close events.

Definition at line 78 of file Event_Handler_T.h.

template<class T>
typedef ACE_HANDLE(T::* ACE_Event_Handler_T::GET_HANDLE)(void) const
 

Definition at line 68 of file Event_Handler_T.h.

template<class T>
typedef int(T::* ACE_Event_Handler_T::IO_HANDLER)(ACE_HANDLE)
 

Handle I/O events.

Definition at line 72 of file Event_Handler_T.h.

template<class T>
typedef void(T::* ACE_Event_Handler_T::SET_HANDLE)(ACE_HANDLE)
 

Definition at line 69 of file Event_Handler_T.h.

template<class T>
typedef int(T::* ACE_Event_Handler_T::SIG_HANDLER)(ACE_HANDLE, siginfo_t*, ucontext_t*)
 

= Initialization and termination methods.

Definition at line 81 of file Event_Handler_T.h.

template<class T>
typedef int(T::* ACE_Event_Handler_T::TO_HANDLER)(const ACE_Time_Value &, const void *)
 

Handle timeout events.

Definition at line 75 of file Event_Handler_T.h.


Constructor & Destructor Documentation

template<class T>
ACE_Event_Handler_T< T >::ACE_Event_Handler_T T *    op_handler,
int    delete_handler,
GET_HANDLE    get_handle = 0,
IO_HANDLER    input = 0,
CL_HANDLER    close = 0,
SIG_HANDLER    sig = 0,
TO_HANDLER    timeout = 0,
IO_HANDLER    output = 0,
SET_HANDLE    set_handle = 0,
IO_HANDLER    except = 0
 

Initialize the op_handler.

Definition at line 38 of file Event_Handler_T.cpp.

References ACE_TRACE.

00047   : op_handler_ (op_handler),
00048     input_handler_ (input_h),
00049     output_handler_ (output_h),
00050     except_handler_ (except_h),
00051     to_handler_ (timeout_h),
00052     cl_handler_ (close_h),
00053     sig_handler_ (sig_h),
00054     delete_handler_ (delete_handler),
00055     set_handle_ (set_handle),
00056     get_handle_ (get_handle)
00057 {
00058   ACE_TRACE ("ACE_Event_Handler_T<T>::ACE_Event_Handler_T");
00059 }

template<class T>
ACE_Event_Handler_T< T >::~ACE_Event_Handler_T void   
 

Close down and delete the <op_handler>.

Definition at line 30 of file Event_Handler_T.cpp.

References ACE_TRACE, delete_handler_, and op_handler_.

00031 {
00032   ACE_TRACE ("ACE_Event_Handler_T<T>::~ACE_Event_Handler_T");
00033   if (this->delete_handler_)
00034     delete this->op_handler_;
00035 }


Member Function Documentation

template<class T>
void ACE_Event_Handler_T< T >::cl_handler CL_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::CL_HANDLER ACE_Event_Handler_T< T >::cl_handler void   
 

Definition at line 160 of file Event_Handler_T.i.

References ACE_TRACE, and cl_handler_.

00161 {
00162   ACE_TRACE ("ACE_Event_Handler_T<T>::cl_handler");
00163   return this->cl_handler_;
00164 }

template<class T>
void ACE_Event_Handler_T< T >::dump void    const
 

Dump the state of an object.

Definition at line 24 of file Event_Handler_T.cpp.

References ACE_TRACE.

00025 {
00026   ACE_TRACE ("ACE_Event_Handler_T<T>::dump");
00027 }

template<class T>
void ACE_Event_Handler_T< T >::except_handler IO_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::IO_HANDLER ACE_Event_Handler_T< T >::except_handler void   
 

Definition at line 132 of file Event_Handler_T.i.

References ACE_TRACE, and except_handler_.

00133 {
00134   ACE_TRACE ("ACE_Event_Handler_T<T>::except_handler");
00135   return this->except_handler_;
00136 }

template<class T>
ACE_INLINE ACE_HANDLE ACE_Event_Handler_T< T >::get_handle void    const [virtual]
 

Get the I/O handle.

Reimplemented from ACE_Event_Handler.

Definition at line 19 of file Event_Handler_T.i.

References ACE_TRACE, get_handle_, and op_handler_.

00020 {
00021   ACE_TRACE ("ACE_Event_Handler_T<T>::get_handle");
00022   return this->get_handle_ == 0 ? -1 : (this->op_handler_->*get_handle_) ();
00023 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_close ACE_HANDLE    fd,
ACE_Reactor_Mask    close_mask
[virtual]
 

Called when a <handle_*()> method returns -1 or when the <remove_handler> method is called on an <ACE_Reactor>. The <close_mask> indicates which event has triggered the <handle_close> method callback on a particular <handle>.

Reimplemented from ACE_Event_Handler.

Definition at line 62 of file Event_Handler_T.i.

References ACE_Reactor_Mask, ACE_TRACE, cl_handler_, and op_handler_.

00063 {
00064   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_close");
00065   return this->cl_handler_ == 0 ? 0 : (this->op_handler_->*cl_handler_) (fd, close_mask);
00066 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_exception ACE_HANDLE    fd = -1 [virtual]
 

Called when an exceptional events occur (e.g., SIGURG).

Reimplemented from ACE_Event_Handler.

Definition at line 48 of file Event_Handler_T.i.

References ACE_TRACE, except_handler_, and op_handler_.

00049 {
00050   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_exception");
00051   return this->except_handler_ == 0 ? 0 : (this->op_handler_->*except_handler_) (fd);
00052 }

template<class T>
void ACE_Event_Handler_T< T >::handle_get GET_HANDLE   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::GET_HANDLE ACE_Event_Handler_T< T >::handle_get void   
 

Definition at line 76 of file Event_Handler_T.i.

References ACE_TRACE, and get_handle_.

00077 {
00078   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_get");
00079   return this->get_handle_;
00080 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_input ACE_HANDLE    fd = -1 [virtual]
 

Called when input events occur (e.g., connection or data).

Reimplemented from ACE_Event_Handler.

Definition at line 34 of file Event_Handler_T.i.

References ACE_TRACE, input_handler_, and op_handler_.

00035 {
00036   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_input");
00037   return this->input_handler_ == 0 ? 0 : (this->op_handler_->*input_handler_) (fd);
00038 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_output ACE_HANDLE    fd = -1 [virtual]
 

Called when output events are possible (e.g., when flow control abates or non-blocking connection completes).

Reimplemented from ACE_Event_Handler.

Definition at line 41 of file Event_Handler_T.i.

References ACE_TRACE, op_handler_, and output_handler_.

00042 {
00043   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_output");
00044   return this->output_handler_ == 0 ? 0 : (this->op_handler_->*output_handler_) (fd);
00045 }

template<class T>
void ACE_Event_Handler_T< T >::handle_set SET_HANDLE   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::SET_HANDLE ACE_Event_Handler_T< T >::handle_set void   
 

Definition at line 90 of file Event_Handler_T.i.

References ACE_TRACE, and set_handle_.

00091 {
00092   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_set");
00093   return this->set_handle_;
00094 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_signal int    signum,
siginfo_t   = 0,
ucontext_t   = 0
[virtual]
 

Called when object is signaled by OS (either via UNIX signals or when a Win32 object becomes signaled).

Reimplemented from ACE_Event_Handler.

Definition at line 69 of file Event_Handler_T.i.

References ACE_TRACE, op_handler_, sig_handler_, and ucontext_t.

00070 {
00071   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_signal");
00072   return this->sig_handler_ == 0 ? 0 : (this->op_handler_->*sig_handler_) (signum, s, u);
00073 }

template<class T>
ACE_INLINE int ACE_Event_Handler_T< T >::handle_timeout const ACE_Time_Value   tv,
const void *    arg = 0
[virtual]
 

Called when timer expires. <current_time> represents the current time that the <Event_Handler> was selected for timeout dispatching and <act> is the asynchronous completion token that was passed in when <schedule_timer> was invoked.

Reimplemented from ACE_Event_Handler.

Definition at line 55 of file Event_Handler_T.i.

References ACE_TRACE, op_handler_, and to_handler_.

00056 {
00057   ACE_TRACE ("ACE_Event_Handler_T<T>::handle_timeout");
00058   return this->to_handler_ == 0 ? 0 : (this->op_handler_->*to_handler_) (tv, arg);
00059 }

template<class T>
void ACE_Event_Handler_T< T >::input_handler IO_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::IO_HANDLER ACE_Event_Handler_T< T >::input_handler void   
 

Definition at line 104 of file Event_Handler_T.i.

References ACE_TRACE, and input_handler_.

00105 {
00106   ACE_TRACE ("ACE_Event_Handler_T<T>::input_handler");
00107   return this->input_handler_;
00108 }

template<class T>
ACE_INLINE void ACE_Event_Handler_T< T >::op_handler T *   
 

Definition at line 5 of file Event_Handler_T.i.

References ACE_TRACE, and op_handler_.

00006 {
00007   ACE_TRACE ("ACE_Event_Handler_T<T>::op_handler");
00008   this->op_handler_ = op;
00009 }

template<class T>
ACE_INLINE T * ACE_Event_Handler_T< T >::op_handler void   
 

Definition at line 12 of file Event_Handler_T.i.

References ACE_TRACE, and op_handler_.

00013 {
00014   ACE_TRACE ("ACE_Event_Handler_T<T>::op_handler");
00015   return this->op_handler_;
00016 }

template<class T>
void ACE_Event_Handler_T< T >::output_handler IO_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::IO_HANDLER ACE_Event_Handler_T< T >::output_handler void   
 

Definition at line 118 of file Event_Handler_T.i.

References ACE_TRACE, and output_handler_.

00119 {
00120   ACE_TRACE ("ACE_Event_Handler_T<T>::output_handler");
00121   return this->output_handler_;
00122 }

template<class T>
ACE_INLINE void ACE_Event_Handler_T< T >::set_handle ACE_HANDLE    [virtual]
 

Set the I/O handle.

Reimplemented from ACE_Event_Handler.

Definition at line 26 of file Event_Handler_T.i.

References ACE_TRACE, op_handler_, and set_handle_.

00027 {
00028   ACE_TRACE ("ACE_Event_Handler_T<T>::set_handle");
00029   if (this->set_handle_ != 0)
00030     (this->op_handler_->*set_handle_) (h);
00031 }

template<class T>
void ACE_Event_Handler_T< T >::sig_handler SIG_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::SIG_HANDLER ACE_Event_Handler_T< T >::sig_handler void   
 

Definition at line 174 of file Event_Handler_T.i.

References ACE_TRACE, and sig_handler_.

00175 {
00176   ACE_TRACE ("ACE_Event_Handler_T<T>::sig_handler");
00177   return this->sig_handler_;
00178 }

template<class T>
void ACE_Event_Handler_T< T >::to_handler TO_HANDLER   
 

template<class T>
ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T< T >::TO_HANDLER ACE_Event_Handler_T< T >::to_handler void   
 

Definition at line 146 of file Event_Handler_T.i.

References ACE_TRACE, and to_handler_.

00147 {
00148   ACE_TRACE ("ACE_Event_Handler_T<T>::to_handler");
00149   return this->to_handler_;
00150 }


Member Data Documentation

template<class T>
ACE_Event_Handler_T::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Definition at line 144 of file Event_Handler_T.h.

template<class T>
CL_HANDLER ACE_Event_Handler_T::cl_handler_ [protected]
 

Handle close events.

Definition at line 159 of file Event_Handler_T.h.

Referenced by cl_handler, and handle_close.

template<class T>
int ACE_Event_Handler_T::delete_handler_ [protected]
 

Keeps track of whether we need to delete the handler in the destructor.

Definition at line 166 of file Event_Handler_T.h.

Referenced by ~ACE_Event_Handler_T.

template<class T>
IO_HANDLER ACE_Event_Handler_T::except_handler_ [protected]
 

Definition at line 153 of file Event_Handler_T.h.

Referenced by except_handler, and handle_exception.

template<class T>
GET_HANDLE ACE_Event_Handler_T::get_handle_ [protected]
 

Definition at line 170 of file Event_Handler_T.h.

Referenced by get_handle, and handle_get.

template<class T>
IO_HANDLER ACE_Event_Handler_T::input_handler_ [protected]
 

Definition at line 151 of file Event_Handler_T.h.

Referenced by handle_input, and input_handler.

template<class T>
T* ACE_Event_Handler_T::op_handler_ [protected]
 

Pointer to the object that handles all the delegated operations.

Definition at line 148 of file Event_Handler_T.h.

Referenced by get_handle, handle_close, handle_exception, handle_input, handle_output, handle_signal, handle_timeout, op_handler, set_handle, and ~ACE_Event_Handler_T.

template<class T>
IO_HANDLER ACE_Event_Handler_T::output_handler_ [protected]
 

Definition at line 152 of file Event_Handler_T.h.

Referenced by handle_output, and output_handler.

template<class T>
SET_HANDLE ACE_Event_Handler_T::set_handle_ [protected]
 

Definition at line 169 of file Event_Handler_T.h.

Referenced by handle_set, and set_handle.

template<class T>
SIG_HANDLER ACE_Event_Handler_T::sig_handler_ [protected]
 

Handle signal events.

Definition at line 162 of file Event_Handler_T.h.

Referenced by handle_signal, and sig_handler.

template<class T>
TO_HANDLER ACE_Event_Handler_T::to_handler_ [protected]
 

Handle timeout events.

Definition at line 156 of file Event_Handler_T.h.

Referenced by handle_timeout, and to_handler.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:47:45 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002