ACE  6.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Attributes | List of all members
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:
Inheritance graph
[legend]
Collaboration diagram for ACE_Event_Handler:
Collaboration graph
[legend]

Classes

class  Policy
 Base class for all handler policies. More...
 
class  Reference_Counting_Policy
 This policy dictates the reference counting requirements for the handler. More...
 

Public Types

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...
 

Public Member Functions

virtual ~ACE_Event_Handler (void)
 Destructor is virtual to enable proper cleanup. 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 priority (void) const
 
virtual void priority (int priority)
 Set the priority of the Event_Handler. 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 &current_time, const void *act=0)
 
virtual int handle_exit (ACE_Process *)
 Called when a process exits. More...
 
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. More...
 
virtual ACE_Reactorreactor (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_Policyreference_counting_policy (void)
 Current Reference_Counting_Policy. More...
 

Static Public Member Functions

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

Protected Types

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

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. More...
 

Protected Attributes

Atomic_Reference_Count reference_count_
 Reference count. More...
 

Private Attributes

int priority_
 Priority of this Event_Handler. More...
 
ACE_Reactorreactor_
 Pointer to the various event demultiplexors. More...
 
Reference_Counting_Policy reference_counting_policy_
 Reference counting requirements. More...
 

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 for implementation of reference counting.

Reference count type.

Member Enumeration Documentation

anonymous enum
Enumerator
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.

anonymous enum
Enumerator
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 

Constructor & Destructor Documentation

ACE_Event_Handler::~ACE_Event_Handler ( void  )
virtual

Destructor is virtual to enable proper cleanup.

ACE_Event_Handler::ACE_Event_Handler ( ACE_Reactor r = 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
int ACE_Event_Handler::handle_close ( ACE_HANDLE  handle,
ACE_Reactor_Mask  close_mask 
)
virtual
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 >, and ACE_Event_Handler_T< T >.

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
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_POSIX_Asynch_Connect, ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, and ACE_Event_Handler_T< T >.

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
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, PEER_ACCEPTOR >, ACE_Buffered_Svc_Handler< PEER_STREAM, SYNCH_TRAITS >, ACE_Svc_Handler< PEER_STREAM, SYNCH_TRAITS >, ACE_NonBlocking_Connect_Handler< SVC_HANDLER >, ACE_Event_Handler_T< T >, ACE_Logging_Strategy, and ACE::Monitor_Control::Monitor_Point_Auto_Updater.

int ACE_Event_Handler::priority ( void  ) const
virtual

Get the priority of the Event_Handler.

Note
Priorities run from MIN_PRIORITY (which is the "lowest priority") to MAX_PRIORITY (which is the "highest priority").
void ACE_Event_Handler::priority ( int  priority)
virtual

Set the priority of the Event_Handler.

void ACE_Event_Handler::reactor ( ACE_Reactor reactor)
virtual

Set the event demultiplexors.

Reimplemented in ACE_Connector< SVC_HANDLER, PEER_CONNECTOR >, and ACE_Logging_Strategy.

ACE_Reactor * ACE_Event_Handler::reactor ( void  ) const
virtual

Get the event demultiplexors.

Reimplemented in ACE_Connector< SVC_HANDLER, PEER_CONNECTOR >, and ACE_Logging_Strategy.

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

Called to figure out whether the handler needs to resumed by the reactor or the application can take care of it. The default value of 0 would be returned which would allow the reactor to take care of resumption of the handler. The application can return a value more than zero and decide to resume the handler themselves.

Note
This method has an affect only when used with the ACE_Dev_Poll_Reactor (and then, only on Linux) or the ACE_TP_Reactor.

Reimplemented in ACE_NonBlocking_Connect_Handler< SVC_HANDLER >.

void ACE_Event_Handler::set_handle ( ACE_HANDLE  )
virtual

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.

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: