# ACE_Event_Handler Class Reference

Provides an abstract interface for handling various types of I/O, timer, and signal events. More...

`#include <Event_Handler.h>`

Inheritance diagram for ACE_Event_Handler:

[legend]
Collaboration diagram for ACE_Event_Handler:

[legend]
List of all members.

## Public Types

typedef long | Reference_Count
| Reference count type.
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 }

## Public Member Functions

virtual | ~ACE_Event_Handler (void)
| Destructor is virtual to enable proper cleanup.
virtual ACE_HANDLE | get_handle (void) const
| Get the I/O handle.
virtual void | set_handle (ACE_HANDLE)
| Set the I/O handle.
virtual int | priority (void) const
| Get the priority of the Event_Handler.
virtual void | priority (int priority)
| Set the priority of the Event_Handler.
virtual int | handle_input (ACE_HANDLE fd=ACE_INVALID_HANDLE)
| Called when input events occur (e.g., connection or data).
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).
virtual int | handle_timeout (const ACE_Time_Value &current_time, const void *act=0)
virtual int | handle_exit (ACE_Process *)
| Called when a process exits.
virtual int | handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
virtual int | handle_signal (int signum, siginfo_t *=0, ucontext_t *=0)
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.
virtual ACE_Reactor * | reactor (void) const
| Get the event demultiplexors.
virtual ACE_Reactor_Timer_Interface * | reactor_timer_interface (void) const
| Get only the reactor's timer related interface.
virtual Reference_Count | add_reference (void)
| Increment reference count on the handler.
virtual Reference_Count | remove_reference (void)
| Decrement reference count on the handler.
Reference_Counting_Policy & | reference_counting_policy (void)
| Current Reference_Counting_Policy.

## Static Public Member Functions

ACE_THR_FUNC_RETURN | read_adapter (void *event_handler)
int | register_stdin_handler (ACE_Event_Handler *eh, ACE_Reactor *reactor, ACE_Thread_Manager *thr_mgr, int flags=THR_DETACHED)
int | remove_stdin_handler (ACE_Reactor *reactor, ACE_Thread_Manager *thr_mgr)
| Performs the inverse of the <register_stdin_handler> method.

## Protected Types

typedef ACE_Atomic_Op< ACE_SYNCH_MUTEX, Reference_Count > | Atomic_Reference_Count
| Typedef for implementation of reference counting.

## Protected Member Functions

| ACE_Event_Handler (ACE_Reactor *=0, int priority=ACE_Event_Handler::LO_PRIORITY)
| Force ACE_Event_Handler to be an abstract base class.

## Protected Attributes

Atomic_Reference_Count | reference_count_
| Reference count.

## Private Attributes

int | priority_
| Priority of this Event_Handler.
ACE_Reactor * | reactor_
| Pointer to the various event demultiplexors.
Reference_Counting_Policy | reference_counting_policy_
| Reference counting requirements.

## Detailed Description

Provides an abstract interface for handling various types of I/O, timer, and signal events.

Subclasses read/write input/output on an I/O descriptor, handle an exception raised on an I/O descriptor, handle a timer's expiration, or handle a signal.

## Member Typedef Documentation

typedef ACE_Atomic_Op<ACE_SYNCH_MUTEX, Reference_Count> ACE_Event_Handler::Atomic_Reference_Count `[protected]`

| Typedef for implementation of reference counting.

typedef long ACE_Event_Handler::Reference_Count

| Reference count type.

## Member Enumeration Documentation

anonymous enum

Enumeration values:

  LO_PRIORITY |
  HI_PRIORITY |
  NULL_MASK |
  READ_MASK |
  WRITE_MASK |
  EXCEPT_MASK |
  ACCEPT_MASK |
  CONNECT_MASK |
  TIMER_MASK |
  QOS_MASK |
  GROUP_QOS_MASK |
  SIGNAL_MASK |
  ALL_EVENTS_MASK |
  RWE_MASK |
  DONT_CALL |

anonymous enum

Enumeration values:

  ACE_EVENT_HANDLER_NOT_RESUMED | The handler is not resumed at all. Could lead to deadlock..
  ACE_REACTOR_RESUMES_HANDLER | The reactor takes responsibility of resuming the handler and is the default
  ACE_APPLICATION_RESUMES_HANDLER | The application takes responsibility of resuming the handler.

## Constructor & Destructor Documentation

ACE_Event_Handler::~ACE_Event_Handler | ( | void |  | ) | `[virtual]`

| Destructor is virtual to enable proper cleanup.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Event_Handler::ACE_Event_Handler | ( | ACE_Reactor * | = `0`,
|  | int | priority = `ACE_Event_Handler::LO_PRIORITY`
| ) | `[protected]`

| Force ACE_Event_Handler to be an abstract base class.

## Member Function Documentation

ACE_Event_Handler::Reference_Count ACE_Event_Handler::add_reference | ( | void |  | ) | `[virtual]`

Increment reference count on the handler.

This method is called when the handler is registered with the Reactor and when the Reactor makes an upcall on the handler. Reference count is 1 when the handler is created.

Returns:
  Current reference count.

ACE_HANDLE ACE_Event_Handler::get_handle | ( | void |  | ) | const`[virtual]`

Get the I/O handle.

Reimplemented in ACE_Acceptor< SVC_HANDLER, >, ACE_Strategy_Acceptor< SVC_HANDLER, >, ACE_Oneshot_Acceptor< SVC_HANDLER, >, ACE_Event_Handler_T< T >, ACE_Name_Proxy, ACE_POSIX_Asynch_Accept, ACE_POSIX_Asynch_Connect, ACE_POSIX_Proactor, ACE_Proactor_Impl, ACE_Service_Manager, ACE_Svc_Handler<, >, ACE_WFMO_Reactor_Notify, ACE_WIN32_Asynch_Connect, ACE_WIN32_Proactor, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.

int ACE_Event_Handler::handle_close | ( | ACE_HANDLE | handle,
|  | 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 in ACE_Acceptor< SVC_HANDLER, >, ACE_Strategy_Acceptor< SVC_HANDLER, >, ACE_Oneshot_Acceptor< SVC_HANDLER, >, ACE_Event_Handler_T< T >, ACE_POSIX_Asynch_Accept, ACE_POSIX_Asynch_Connect, ACE_Service_Manager, ACE_Svc_Handler<, >, ACE_WIN32_Asynch_Connect, ACE_WIN32_Proactor, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.

int ACE_Event_Handler::handle_exception | ( | ACE_HANDLE | fd = `ACE_INVALID_HANDLE` | ) | `[virtual]`

| Called when an exceptional events occur (e.g., SIGURG). Reimplemented in ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, ACE_Event_Handler_T< T >, and ACE_WIN32_Asynch_Connect.

int ACE_Event_Handler::handle_exit | ( | ACE_Process * |  | ) | `[virtual]`

| Called when a process exits.

int ACE_Event_Handler::handle_group_qos | ( | ACE_HANDLE | = `ACE_INVALID_HANDLE` | ) | `[virtual]`

int ACE_Event_Handler::handle_input | ( | ACE_HANDLE | fd = `ACE_INVALID_HANDLE` | ) | `[virtual]`

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

Reimplemented in ACE_Acceptor< SVC_HANDLER, >, ACE_Oneshot_Acceptor< SVC_HANDLER, >, ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, ACE_Dev_Poll_Reactor_Notify, ACE_Event_Handler_T< T >, ACE_POSIX_Asynch_Accept, ACE_Select_Reactor_Notify, ACE_Service_Manager, ACE_WIN32_Asynch_Connect, and ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

int ACE_Event_Handler::handle_output | ( | ACE_HANDLE | fd = `ACE_INVALID_HANDLE` | ) | `[virtual]`

| Called when output events are possible (e.g., when flow control abates or non-blocking connection completes). Reimplemented in ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, ACE_Event_Handler_T< T >, ACE_POSIX_Asynch_Connect, and ACE_WIN32_Asynch_Connect.

int ACE_Event_Handler::handle_qos | ( | ACE_HANDLE | = `ACE_INVALID_HANDLE` | ) | `[virtual]`

int ACE_Event_Handler::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 in ACE_Strategy_Acceptor< SVC_HANDLER, >, ACE_Event_Handler_T< T >, ACE_MMAP_Memory_Pool, ACE_Process_Manager, ACE_Service_Manager, ACE_Shared_Memory_Pool, ACE_Sig_Adapter, ACE_Test_and_Set< ACE_LOCK, TYPE >, ACE_Async_Timer_Queue_Adapter< TQ >, ACE_Wakeup_All_Threads_Handler, ACE_WFMO_Reactor_Notify, and ACE_WIN32_Proactor.

int ACE_Event_Handler::handle_timeout | ( | const ACE_Time_Value & | current_time,
|  | const void * | act = `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 in ACE_Oneshot_Acceptor< SVC_HANDLER, >, ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, ACE_Event_Handler_T< T >, ACE_Logging_Strategy, ACE_Svc_Handler<, >, ACE_Buffered_Svc_Handler<, >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.

void ACE_Event_Handler::priority | ( | int | priority | ) | `[virtual]`

| Set the priority of the Event_Handler.

int ACE_Event_Handler::priority | ( | void |  | ) | const`[virtual]`

| Get the priority of the Event_Handler.

ACE_Reactor * ACE_Event_Handler::reactor | ( | void |  | ) | const`[virtual]`

| Get the event demultiplexors. Reimplemented in ACE_Connector< SVC_HANDLER, >, and ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

void ACE_Event_Handler::reactor | ( | ACE_Reactor * | reactor | ) | `[virtual]`

| Set the event demultiplexors. Reimplemented in ACE_Connector< SVC_HANDLER, >, and ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

ACE_Reactor_Timer_Interface * ACE_Event_Handler::reactor_timer_interface | ( | void |  | ) | const`[virtual]`

| Get only the reactor's timer related interface.

ACE_THR_FUNC_RETURN ACE_Event_Handler::read_adapter | ( | void * | event_handler | ) | `[static]`

Used to read from non-socket ACE_HANDLEs in our own thread to work around Win32 limitations that don't allow us to <select> on non-sockets (such as ACE_STDIN). This is commonly used in situations where the Reactor is used to demultiplex read events on ACE_STDIN on UNIX. Note that <event_handler> must be a subclass of ACE_Event_Handler. If the <get_handle> method of this event handler returns <ace_invalid_handle> we default to reading from ACE_STDIN.

ACE_Event_Handler::Reference_Counting_Policy & ACE_Event_Handler::reference_counting_policy | ( | void |  | ) |

| Current Reference_Counting_Policy.

int ACE_Event_Handler::register_stdin_handler | ( | ACE_Event_Handler * | eh,
|  | ACE_Reactor * | reactor,
|  | ACE_Thread_Manager * | thr_mgr,
|  | int | flags = `THR_DETACHED`
| ) | `[static]`

| Abstracts away from the differences between Win32 and ACE with respect to reading from ACE_STDIN, which is non-<select>'able on Win32.

ACE_Event_Handler::Reference_Count ACE_Event_Handler::remove_reference | ( | void |  | ) | `[virtual]`

Decrement reference count on the handler.

This method is called when the handler is removed from the Reactor and when an upcall made on the handler by the Reactor completes. Handler is deleted when the reference count reaches 0.

Returns:
  Current reference count.

int ACE_Event_Handler::remove_stdin_handler | ( | ACE_Reactor * | reactor,
|  | ACE_Thread_Manager * | thr_mgr
| ) | `[static]`

| Performs the inverse of the <register_stdin_handler> method.

int ACE_Event_Handler::resume_handler | ( | void |  | ) | `[virtual]`

| Reimplemented in ACE_NonBlocking_Connect_Handler< SVC_HANDLER >.

void ACE_Event_Handler::set_handle | ( | ACE_HANDLE |  | ) | `[virtual]`

| Set the I/O handle. Reimplemented in ACE_Event_Handler_T< T >, ACE_POSIX_Asynch_Accept, ACE_POSIX_Asynch_Connect, ACE_Svc_Handler<, >, ACE_WIN32_Asynch_Connect, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.

## Member Data Documentation

int ACE_Event_Handler::priority_ `[private]`

| Priority of this Event_Handler.

ACE_Reactor* ACE_Event_Handler::reactor_ `[private]`

| Pointer to the various event demultiplexors. Reimplemented in ACE_Asynch_Pseudo_Task, ACE_Connector< SVC_HANDLER, >, ACE_Name_Proxy, and ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

Atomic_Reference_Count ACE_Event_Handler::reference_count_ `[protected]`

| Reference count.

Reference_Counting_Policy ACE_Event_Handler::reference_counting_policy_ `[private]`

| Reference counting requirements.

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

- Event_Handler.h
- Event_Handler.cpp