|
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 )(int, siginfo_t *, ucontext_t *) |
| = Initialization and termination methods. More...
|
|
enum | {
LO_PRIORITY = 0,
HI_PRIORITY = 10,
NULL_MASK = 0,
READ_MASK = (1 << 0),
WRITE_MASK = (1 << 1),
EXCEPT_MASK = (1 << 2),
ACCEPT_MASK = (1 << 3),
CONNECT_MASK = (1 << 4),
TIMER_MASK = (1 << 5),
QOS_MASK = (1 << 6),
GROUP_QOS_MASK = (1 << 7),
SIGNAL_MASK = (1 << 8),
ALL_EVENTS_MASK,
RWE_MASK,
DONT_CALL = (1 << 9)
} |
|
enum | { ACE_EVENT_HANDLER_NOT_RESUMED = -1,
ACE_REACTOR_RESUMES_HANDLER = 0,
ACE_APPLICATION_RESUMES_HANDLER
} |
|
typedef long | Reference_Count |
| Reference count type. More...
|
|
|
| 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=ACE_INVALID_HANDLE) |
| Called when input events occur (e.g., connection or data). More...
|
|
virtual int | handle_output (ACE_HANDLE fd=ACE_INVALID_HANDLE) |
|
virtual int | handle_exception (ACE_HANDLE fd=ACE_INVALID_HANDLE) |
| 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) |
|
virtual int | handle_signal (int signum, siginfo_t *=0, ucontext_t *=0) |
|
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...
|
|
virtual | ~ACE_Event_Handler (void) |
| Destructor is virtual to enable proper cleanup. More...
|
|
virtual int | priority (void) const |
|
virtual void | priority (int priority) |
| Set the priority of the Event_Handler. More...
|
|
virtual int | handle_exit (ACE_Process *) |
| Called when a process exits. More...
|
|
virtual int | resume_handler (void) |
|
virtual int | handle_qos (ACE_HANDLE=ACE_INVALID_HANDLE) |
|
virtual int | handle_group_qos (ACE_HANDLE=ACE_INVALID_HANDLE) |
|
virtual void | reactor (ACE_Reactor *reactor) |
| Set the event demultiplexors. More...
|
|
virtual ACE_Reactor * | reactor (void) const |
| Get the event demultiplexors. More...
|
|
virtual
ACE_Reactor_Timer_Interface * | reactor_timer_interface (void) const |
| Get only the reactor's timer related interface. More...
|
|
virtual Reference_Count | add_reference (void) |
| Increment reference count on the handler. More...
|
|
virtual Reference_Count | remove_reference (void) |
| Decrement reference count on the handler. More...
|
|
Reference_Counting_Policy & | reference_counting_policy (void) |
| Current Reference_Counting_Policy. More...
|
|
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.lav.nosp@m.ende.nosp@m.r@iso.nosp@m.de.c.nosp@m.om) 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 parameterize 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.