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

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]
List of all members.

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 }

Public Methods

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
 Get the priority of the Event_Handler. More...

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

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


Static Public Methods

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


Protected Methods

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


Private Attributes

int priority_
 Priority of this Event_Handler. More...

ACE_Reactorreactor_
 Pointer to the various event demultiplexors. 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.

Definition at line 43 of file Event_Handler.h.


Member Enumeration Documentation

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.

Definition at line 133 of file Event_Handler.h.

00134     {
00135       /// The handler is not resumed at all. Could lead to deadlock..
00136       ACE_EVENT_HANDLER_NOT_RESUMED = -1,
00137       /// The reactor takes responsibility of resuming the handler and
00138       /// is the default
00139       ACE_REACTOR_RESUMES_HANDLER = 0,
00140       /// The application takes responsibility of resuming the handler
00141       ACE_APPLICATION_RESUMES_HANDLER
00142     };

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 

Definition at line 46 of file Event_Handler.h.

00047   {
00048     LO_PRIORITY = 0,
00049     HI_PRIORITY = 10,
00050     NULL_MASK = 0,
00051 #if defined (ACE_USE_POLL)
00052     READ_MASK = POLLIN,
00053     WRITE_MASK = POLLOUT,
00054     EXCEPT_MASK = POLLPRI,
00055 #else /* USE SELECT */
00056     READ_MASK = (1 << 0),
00057     WRITE_MASK = (1 << 1),
00058     EXCEPT_MASK = (1 << 2),
00059 #endif /* ACE_USE_POLL */
00060     ACCEPT_MASK = (1 << 3),
00061     CONNECT_MASK = (1 << 4),
00062     TIMER_MASK = (1 << 5),
00063     QOS_MASK = (1 << 6),
00064     GROUP_QOS_MASK = (1 << 7),
00065     SIGNAL_MASK = (1 << 8),
00066     ALL_EVENTS_MASK = READ_MASK |
00067                       WRITE_MASK |
00068                       EXCEPT_MASK |
00069                       ACCEPT_MASK |
00070                       CONNECT_MASK |
00071                       TIMER_MASK |
00072                       QOS_MASK |
00073                       GROUP_QOS_MASK |
00074                       SIGNAL_MASK,
00075     RWE_MASK = READ_MASK |
00076                WRITE_MASK |
00077                EXCEPT_MASK,
00078     DONT_CALL = (1 << 9)
00079   };


Constructor & Destructor Documentation

ACE_Event_Handler::~ACE_Event_Handler void    [virtual]
 

Destructor is virtual to enable proper cleanup.

Definition at line 28 of file Event_Handler.cpp.

References ACE_Reactor::purge_pending_notifications, and reactor_.

00029 {
00030   // ACE_TRACE ("ACE_Event_Handler::~ACE_Event_Handler");
00031   if (this->reactor_ != 0)
00032     {
00033       ACE_Errno_Guard guard (errno);     // purge may get ENOTSUP
00034       this->reactor_->purge_pending_notifications (this);
00035     }
00036 }

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.

Definition at line 20 of file Event_Handler.cpp.

00022   : priority_ (p),
00023     reactor_ (r)
00024 {
00025   // ACE_TRACE ("ACE_Event_Handler::ACE_Event_Handler");
00026 }


Member Function Documentation

ACE_HANDLE ACE_Event_Handler::get_handle void    const [virtual]
 

Get the I/O handle.

Reimplemented in ACE_Acceptor.

Definition at line 41 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Select_Reactor_Handler_Repository::bind, ACE_Dev_Poll_Reactor_Handler_Repository::bind, ACE_WFMO_Reactor_Handler_Repository::bind_i, ACE_WFMO_Reactor::cancel_wakeup, ACE_Select_Reactor_T::cancel_wakeup, ACE_Dev_Poll_Reactor::cancel_wakeup, ACE_Select_Reactor_T::check_handles, ACE_Select_Reactor_Handler_Repository::dump, ACE_WFMO_Reactor::mask_ops, ACE_TP_Reactor::mask_ops, ACE_Select_Reactor_T::mask_ops, ACE_Dev_Poll_Reactor::mask_ops, read_adapter, ACE_Select_Reactor_T::ready_ops, ACE_Dev_Poll_Reactor::register_handler, ACE_WFMO_Reactor::register_handler_i, ACE_WFMO_Reactor::remove_handler, ACE_TP_Reactor::remove_handler, ACE_Dev_Poll_Reactor::remove_handler, ACE_WFMO_Reactor::resume_handler, ACE_Select_Reactor_T::resume_handler, ACE_Dev_Poll_Reactor::resume_handler, ACE_Select_Reactor_T::resume_handlers, ACE_WFMO_Reactor::schedule_wakeup, ACE_Select_Reactor_T::schedule_wakeup, ACE_Dev_Poll_Reactor::schedule_wakeup, ACE_WFMO_Reactor::suspend_handler, ACE_Select_Reactor_T::suspend_handler, ACE_Dev_Poll_Reactor::suspend_handler, and ACE_Select_Reactor_T::suspend_handlers.

00042 {
00043   ACE_TRACE ("ACE_Event_Handler::get_handle");
00044   return ACE_INVALID_HANDLE;
00045 }

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.

Definition at line 77 of file Event_Handler.cpp.

References ACE_Reactor_Mask, and ACE_TRACE.

Referenced by ACE_Event_Handler_Handle_Timeout_Upcall::cancellation, ACE_Process_Manager::close, ACE_Sig_Handler::dispatch, ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_WFMO_Reactor_Notify::handle_signal, ACE_WFMO_Reactor_Handler_Repository::make_changes_in_current_infos, ACE_WFMO_Reactor_Handler_Repository::make_changes_in_suspension_infos, ACE_WFMO_Reactor_Handler_Repository::make_changes_in_to_be_added_infos, ACE_Process_Manager::notify_proc_handler, read_adapter, ACE_Process_Manager::register_handler, ACE_TP_Reactor::remove_handler, ACE_WFMO_Reactor_Handler_Repository::remove_handler_i, ACE_Dev_Poll_Reactor::remove_handler_i, ACE_Process_Manager::remove_proc, ACE_WFMO_Reactor_Handler_Repository::remove_suspended_handler_i, ACE_WFMO_Reactor_Handler_Repository::remove_to_be_added_handler_i, and ACE_Select_Reactor_Handler_Repository::unbind.

00078 {
00079   ACE_TRACE ("ACE_Event_Handler::handle_close");
00080   return -1;
00081 }

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

Definition at line 104 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Dev_Poll_Reactor::dispatch_io_events, ACE_Select_Reactor_T::dispatch_io_handlers, ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_TP_Reactor::get_socket_event_info, ACE_WFMO_Reactor_Notify::handle_signal, and ACE_WFMO_Reactor::upcall.

00105 {
00106   ACE_TRACE ("ACE_Event_Handler::handle_exception");
00107   return -1;
00108 }

int ACE_Event_Handler::handle_exit ACE_Process   [virtual]
 

Called when a process exits.

Definition at line 122 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Process_Manager::notify_proc_handler.

00123 {
00124   ACE_TRACE ("ACE_Event_Handler::handle_exit");
00125   return -1;
00126 }

int ACE_Event_Handler::handle_group_qos ACE_HANDLE    = ACE_INVALID_HANDLE [virtual]
 

Definition at line 156 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_WFMO_Reactor_Notify::handle_signal, and ACE_WFMO_Reactor::upcall.

00157 {
00158   ACE_TRACE ("ACE_Event_Handler::handle_group_qos");
00159   return -1;
00160 }

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.

Definition at line 86 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Dev_Poll_Reactor::dispatch_io_events, ACE_Select_Reactor_T::dispatch_io_handlers, ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_TP_Reactor::get_socket_event_info, ACE_WFMO_Reactor_Notify::handle_signal, read_adapter, and ACE_WFMO_Reactor::upcall.

00087 {
00088   ACE_TRACE ("ACE_Event_Handler::handle_input");
00089   return -1;
00090 }

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

Definition at line 95 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Dev_Poll_Reactor::dispatch_io_events, ACE_Select_Reactor_T::dispatch_io_handlers, ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_TP_Reactor::get_socket_event_info, ACE_WFMO_Reactor_Notify::handle_signal, and ACE_WFMO_Reactor::upcall.

00096 {
00097   ACE_TRACE ("ACE_Event_Handler::handle_output");
00098   return -1;
00099 }

int ACE_Event_Handler::handle_qos ACE_HANDLE    = ACE_INVALID_HANDLE [virtual]
 

Definition at line 149 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Select_Reactor_Notify::dispatch_notify, ACE_Dev_Poll_Reactor_Notify::dispatch_notify, ACE_WFMO_Reactor_Notify::handle_signal, and ACE_WFMO_Reactor::upcall.

00150 {
00151   ACE_TRACE ("ACE_Event_Handler::handle_qos");
00152   return -1;
00153 }

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.

Definition at line 131 of file Event_Handler.cpp.

References ACE_TRACE, and ucontext_t.

Referenced by ACE_Sig_Handler::dispatch, ACE_Sig_Adapter::handle_signal, and ACE_WFMO_Reactor::simple_dispatch_handler.

00132 {
00133   ACE_TRACE ("ACE_Event_Handler::handle_signal");
00134   return -1;
00135 }

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.

Definition at line 113 of file Event_Handler.cpp.

References ACE_TRACE.

Referenced by ACE_Event_Handler_Handle_Timeout_Upcall::timeout.

00114 {
00115   ACE_TRACE ("ACE_Event_Handler::handle_timeout");
00116   return -1;
00117 }

void ACE_Event_Handler::priority int    priority [virtual]
 

Set the priority of the Event_Handler.

Definition at line 67 of file Event_Handler.cpp.

References ACE_TRACE, priority, and priority_.

00068 {
00069   ACE_TRACE ("ACE_Event_Handler::priority");
00070   this->priority_ = priority;
00071 }

int ACE_Event_Handler::priority void    const [virtual]
 

Get the priority of the Event_Handler.

Definition at line 58 of file Event_Handler.cpp.

References ACE_TRACE, and priority_.

Referenced by ACE_POSIX_Asynch_Accept::accept, ACE_Thread_Timer_Queue_Adapter::activate, ACE_Task_Base::activate, ACE_WIN32_Asynch_Connect::connect, ACE_POSIX_Asynch_Connect::connect, ACE_WIN32_Proactor::create_asynch_accept_result, ACE_POSIX_Proactor::create_asynch_accept_result, ACE_WIN32_Proactor::create_asynch_connect_result, ACE_POSIX_Proactor::create_asynch_connect_result, ACE_WIN32_Proactor::create_asynch_read_dgram_result, ACE_POSIX_Proactor::create_asynch_read_dgram_result, ACE_WIN32_Proactor::create_asynch_read_file_result, ACE_POSIX_Proactor::create_asynch_read_file_result, ACE_WIN32_Proactor::create_asynch_read_stream_result, ACE_POSIX_Proactor::create_asynch_read_stream_result, ACE_WIN32_Proactor::create_asynch_timer, ACE_POSIX_Proactor::create_asynch_timer, ACE_WIN32_Proactor::create_asynch_transmit_file_result, ACE_POSIX_Proactor::create_asynch_transmit_file_result, ACE_WIN32_Proactor::create_asynch_write_dgram_result, ACE_POSIX_Proactor::create_asynch_write_dgram_result, ACE_WIN32_Proactor::create_asynch_write_file_result, ACE_POSIX_Proactor::create_asynch_write_file_result, ACE_WIN32_Proactor::create_asynch_write_stream_result, ACE_POSIX_Proactor::create_asynch_write_stream_result, ACE_Priority_Reactor::dispatch_io_set, ACE_Logging_Strategy::priorities, and priority.

00059 {
00060   ACE_TRACE ("ACE_Event_Handler::priority");
00061   return this->priority_;
00062 }

ACE_Reactor * ACE_Event_Handler::reactor void    const [virtual]
 

Get the event demultiplexors.

Definition at line 170 of file Event_Handler.cpp.

References ACE_TRACE, and reactor_.

Referenced by ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::ACE_Acceptor, ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor, ACE_Svc_Handler::ACE_Svc_Handler, ACE_Process_Manager::append_proc, ACE_Oneshot_Acceptor::cancel, ACE_Process_Manager::close, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::create_AST, ACE_Logging_Strategy::fini, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::handle_close, ACE_Oneshot_Acceptor::handle_close, ACE_Strategy_Acceptor::handle_close, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::handle_close, ACE_Oneshot_Acceptor::handle_input, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::handle_output, ACE_Process_Manager::handle_signal, ACE_Logging_Strategy::init, ACE_Svc_Handler::open, ACE_Process_Manager::open, ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::open, ACE_Process_Manager::remove_proc, ACE_Oneshot_Acceptor::resume, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::resume, ACE_Svc_Handler::shutdown, ACE_Oneshot_Acceptor::suspend, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::suspend, ACE_Process_Manager::wait, ACE_POSIX_Asynch_Accept::~ACE_POSIX_Asynch_Accept, ACE_POSIX_Asynch_Connect::~ACE_POSIX_Asynch_Connect, and ACE_WIN32_Asynch_Connect::~ACE_WIN32_Asynch_Connect.

00171 {
00172   ACE_TRACE ("ACE_Event_Handler::reactor");
00173   return this->reactor_;
00174 }

void ACE_Event_Handler::reactor ACE_Reactor   reactor [virtual]
 

Set the event demultiplexors.

Definition at line 163 of file Event_Handler.cpp.

References ACE_TRACE, and reactor_.

Referenced by ACE_Svc_Handler::ACE_Svc_Handler, ACE_Reactor::notify, read_adapter, ACE_Reactor::register_handler, register_stdin_handler, ACE_Reactor::schedule_timer, ACE_Reactor::schedule_wakeup, and ACE_Event_Handler_Handle_Timeout_Upcall::timeout.

00164 {
00165   ACE_TRACE ("ACE_Event_Handler::reactor");
00166   this->reactor_ = reactor;
00167 }

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.

Definition at line 179 of file Event_Handler.cpp.

References ACE_STDIN, get_handle, handle_close, handle_input, reactor, and READ_MASK.

Referenced by register_stdin_handler.

00180 {
00181   ACE_Event_Handler *this_ptr = (ACE_Event_Handler *) args;
00182 
00183   ACE_HANDLE handle = this_ptr->get_handle ();
00184   if (handle == ACE_INVALID_HANDLE)
00185     handle = ACE_STDIN;
00186 
00187   while (this_ptr->handle_input (handle) != -1)
00188     continue;
00189 
00190   this_ptr->handle_close (handle,
00191                           ACE_Event_Handler::READ_MASK);
00192   this_ptr->reactor ()->notify ();
00193 
00194   return 0;
00195 }

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.

Definition at line 198 of file Event_Handler.cpp.

References ACE_STDIN, reactor, read_adapter, READ_MASK, ACE_Reactor::register_handler, and ACE_Thread_Manager::spawn.

00202 {
00203 #if defined (ACE_WIN32) || defined (ACE_PSOS)
00204   ACE_UNUSED_ARG (reactor);
00205 
00206   eh->reactor (reactor);
00207   return thr_mgr->spawn (&read_adapter, (void *) eh, flags);
00208 #else
00209   // Keep compilers happy.
00210   ACE_UNUSED_ARG (flags);
00211   ACE_UNUSED_ARG (thr_mgr);
00212   return reactor->register_handler (ACE_STDIN,
00213                                     eh,
00214                                     ACE_Event_Handler::READ_MASK);
00215 #endif /* ACE_WIN32 || ACE_PSOS */
00216 }

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.

Definition at line 219 of file Event_Handler.cpp.

References ACE_STDIN, READ_MASK, and ACE_Reactor::remove_handler.

00221 {
00222 #if defined (ACE_WIN32)
00223   ACE_UNUSED_ARG (reactor);
00224   ACE_UNUSED_ARG (thr_mgr);
00225 
00226   // What should we do here?
00227   ACE_NOTSUP_RETURN (-1);
00228 #else
00229   // Keep compilers happy.
00230   ACE_UNUSED_ARG (thr_mgr);
00231   return reactor->remove_handler (ACE_STDIN,
00232                                   ACE_Event_Handler::READ_MASK);
00233 #endif /* ACE_WIN32 */
00234 }

int ACE_Event_Handler::resume_handler void    [virtual]
 

Reimplemented in ACE_Connector.

Definition at line 138 of file Event_Handler.cpp.

References ACE_REACTOR_RESUMES_HANDLER, and ACE_TRACE.

Referenced by ACE_TP_Reactor::handle_socket_events.

00139 {
00140   ACE_TRACE ("ACE_Event_Handler::resume_handler");
00141 
00142   // Return a default value and allow the reactor to take care of
00143   // resuming the handler
00144   return ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER;
00145 }

void ACE_Event_Handler::set_handle ACE_HANDLE    [virtual]
 

Set the I/O handle.

Reimplemented in ACE_Event_Handler_T.

Definition at line 50 of file Event_Handler.cpp.

References ACE_TRACE.

00051 {
00052   ACE_TRACE ("ACE_Event_Handler::set_handle");
00053 }


Member Data Documentation

int ACE_Event_Handler::priority_ [private]
 

Priority of this Event_Handler.

Definition at line 201 of file Event_Handler.h.

Referenced by priority.

ACE_Reactor* ACE_Event_Handler::reactor_ [private]
 

Pointer to the various event demultiplexors.

Reimplemented in ACE_Asynch_Pseudo_Task.

Definition at line 204 of file Event_Handler.h.

Referenced by reactor, and ~ACE_Event_Handler.


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