#include <Event_Handler.h>
Inheritance diagram for ACE_Event_Handler:
Public Types | |
typedef long | Reference_Count |
Reference count type. | |
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) | |
ACE_EVENT_HANDLER_NOT_RESUMED = -1 | |
The handler is not resumed at all. Could lead to deadlock.. | |
ACE_REACTOR_RESUMES_HANDLER = 0 | |
ACE_APPLICATION_RESUMES_HANDLER | |
The application takes responsibility of resuming the handler. | |
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 ¤t_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 | |
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. | |
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. | |
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... |
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 48 of file Event_Handler.h.
typedef ACE_Atomic_Op<ACE_SYNCH_MUTEX, Reference_Count> ACE_Event_Handler::Atomic_Reference_Count [protected] |
typedef long ACE_Event_Handler::Reference_Count |
anonymous enum |
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 51 of file Event_Handler.h.
00052 { 00053 LO_PRIORITY = 0, 00054 HI_PRIORITY = 10, 00055 NULL_MASK = 0, 00056 #if defined (ACE_USE_POLL) 00057 READ_MASK = POLLIN, 00058 WRITE_MASK = POLLOUT, 00059 EXCEPT_MASK = POLLPRI, 00060 #else /* USE SELECT */ 00061 READ_MASK = (1 << 0), 00062 WRITE_MASK = (1 << 1), 00063 EXCEPT_MASK = (1 << 2), 00064 #endif /* ACE_USE_POLL */ 00065 ACCEPT_MASK = (1 << 3), 00066 CONNECT_MASK = (1 << 4), 00067 TIMER_MASK = (1 << 5), 00068 QOS_MASK = (1 << 6), 00069 GROUP_QOS_MASK = (1 << 7), 00070 SIGNAL_MASK = (1 << 8), 00071 ALL_EVENTS_MASK = READ_MASK | 00072 WRITE_MASK | 00073 EXCEPT_MASK | 00074 ACCEPT_MASK | 00075 CONNECT_MASK | 00076 TIMER_MASK | 00077 QOS_MASK | 00078 GROUP_QOS_MASK | 00079 SIGNAL_MASK, 00080 RWE_MASK = READ_MASK | 00081 WRITE_MASK | 00082 EXCEPT_MASK, 00083 DONT_CALL = (1 << 9) 00084 };
anonymous enum |
Definition at line 138 of file Event_Handler.h.
00139 { 00140 /// The handler is not resumed at all. Could lead to deadlock.. 00141 ACE_EVENT_HANDLER_NOT_RESUMED = -1, 00142 /// The reactor takes responsibility of resuming the handler and 00143 /// is the default 00144 ACE_REACTOR_RESUMES_HANDLER = 0, 00145 /// The application takes responsibility of resuming the handler 00146 ACE_APPLICATION_RESUMES_HANDLER 00147 };
ACE_Event_Handler::~ACE_Event_Handler | ( | void | ) | [virtual] |
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.
Definition at line 24 of file Event_Handler.cpp.
00026 : reference_count_ (1), 00027 priority_ (p), 00028 reactor_ (r), 00029 reference_counting_policy_ (Reference_Counting_Policy::DISABLED) 00030 { 00031 // ACE_TRACE ("ACE_Event_Handler::ACE_Event_Handler"); 00032 }
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.
Definition at line 185 of file Event_Handler.cpp.
References ACE_Event_Handler::Reference_Counting_Policy::ENABLED, reference_count_, reference_counting_policy(), and ACE_Event_Handler::Reference_Counting_Policy::value().
Referenced by ACE_Event_Handler_var::ACE_Event_Handler_var(), ACE_Select_Reactor_Handler_Repository::bind(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler_i(), ACE_TP_Reactor::handle_socket_events(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i(), ACE_Select_Reactor_Notify::notify(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::preinvoke(), and ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::registration().
00186 { 00187 bool const reference_counting_required = 00188 this->reference_counting_policy ().value () == 00189 ACE_Event_Handler::Reference_Counting_Policy::ENABLED; 00190 00191 if (reference_counting_required) 00192 return ++this->reference_count_; 00193 else 00194 return 1; 00195 }
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_Name_Proxy, ACE_Service_Manager, ACE_Svc_Handler<, >, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 42 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_Handler_Repository::bind(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup(), and ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler().
00043 { 00044 ACE_TRACE ("ACE_Event_Handler::get_handle"); 00045 return ACE_INVALID_HANDLE; 00046 }
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_Service_Manager, ACE_Svc_Handler<, >, ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 78 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::cancel_type(), ACE_Process_Manager::close(), ACE_Sig_Handler::dispatch(), ACE_Select_Reactor_Notify::dispatch_notify(), read_adapter(), ACE_Process_Manager::register_handler(), ACE_Process_Manager::remove_proc(), and ACE_Select_Reactor_Handler_Repository::unbind().
00079 { 00080 ACE_TRACE ("ACE_Event_Handler::handle_close"); 00081 return -1; 00082 }
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 >.
Definition at line 105 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers(), ACE_Select_Reactor_Notify::dispatch_notify(), and ACE_TP_Reactor::get_socket_event_info().
00106 { 00107 ACE_TRACE ("ACE_Event_Handler::handle_exception"); 00108 return -1; 00109 }
int ACE_Event_Handler::handle_exit | ( | ACE_Process * | ) | [virtual] |
Called when a process exits.
Definition at line 123 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Process_Manager::notify_proc_handler().
00124 { 00125 ACE_TRACE ("ACE_Event_Handler::handle_exit"); 00126 return -1; 00127 }
int ACE_Event_Handler::handle_group_qos | ( | ACE_HANDLE | = ACE_INVALID_HANDLE |
) | [virtual] |
Definition at line 157 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_Notify::dispatch_notify().
00158 { 00159 ACE_TRACE ("ACE_Event_Handler::handle_group_qos"); 00160 return -1; 00161 }
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_Process_Manager, ACE_Select_Reactor_Notify, ACE_Service_Manager, and ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.
Definition at line 87 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers(), ACE_Select_Reactor_Notify::dispatch_notify(), ACE_TP_Reactor::get_socket_event_info(), and read_adapter().
00088 { 00089 ACE_TRACE ("ACE_Event_Handler::handle_input"); 00090 return -1; 00091 }
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 >.
Definition at line 96 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers(), ACE_Select_Reactor_Notify::dispatch_notify(), and ACE_TP_Reactor::get_socket_event_info().
00097 { 00098 ACE_TRACE ("ACE_Event_Handler::handle_output"); 00099 return -1; 00100 }
int ACE_Event_Handler::handle_qos | ( | ACE_HANDLE | = ACE_INVALID_HANDLE |
) | [virtual] |
Definition at line 150 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Select_Reactor_Notify::dispatch_notify().
00151 { 00152 ACE_TRACE ("ACE_Event_Handler::handle_qos"); 00153 return -1; 00154 }
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_MMAP_Memory_Pool, ACE_Process_Manager, ACE_Service_Manager, ACE_Shared_Memory_Pool, ACE_Sig_Adapter, ACE_Test_and_Set< ACE_LOCK, TYPE >, and ACE_Async_Timer_Queue_Adapter< TQ >.
Definition at line 132 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Sig_Handler::dispatch(), and ACE_Sig_Adapter::handle_signal().
00133 { 00134 ACE_TRACE ("ACE_Event_Handler::handle_signal"); 00135 return -1; 00136 }
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_Logging_Strategy, ACE::Monitor_Control::Monitor_Point_Auto_Updater, ACE_Svc_Handler<, >, ACE_Buffered_Svc_Handler<, >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 114 of file Event_Handler.cpp.
References ACE_TRACE.
Referenced by ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::timeout().
00115 { 00116 ACE_TRACE ("ACE_Event_Handler::handle_timeout"); 00117 return -1; 00118 }
void ACE_Event_Handler::priority | ( | int | priority | ) | [virtual] |
int ACE_Event_Handler::priority | ( | void | ) | const [virtual] |
Get the priority of the Event_Handler.
Definition at line 59 of file Event_Handler.cpp.
References ACE_TRACE, and priority_.
Referenced by ACE_Priority_Reactor::build_bucket().
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 >.
Definition at line 171 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< SVC_HANDLER, >::ACE_Oneshot_Acceptor(), ACE_Svc_Handler<, >::ACE_Svc_Handler(), ACE_Process_Manager::append_proc(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::cancel(), ACE_Process_Manager::close(), ACE_Strategy_Acceptor< SVC_HANDLER, >::handle_close(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::handle_close(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::handle_input(), ACE_Process_Manager::handle_signal(), ACE_Logging_Strategy::init(), ACE_Svc_Handler<, >::open(), ACE_Process_Manager::open(), reactor(), register_stdin_handler(), ACE_Process_Manager::remove_proc(), remove_stdin_handler(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::resume(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::resume(), ACE_Svc_Handler<, >::shutdown(), ACE_Oneshot_Acceptor< SVC_HANDLER, >::suspend(), and ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::suspend().
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 >.
Definition at line 164 of file Event_Handler.cpp.
References ACE_TRACE, reactor(), and reactor_.
Referenced by ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >::nonblocking_connect(), ACE_Reactor::notify(), read_adapter(), ACE_Reactor::register_handler(), register_stdin_handler(), ACE_Reactor::schedule_timer(), and ACE_Reactor::schedule_wakeup().
ACE_Reactor_Timer_Interface * ACE_Event_Handler::reactor_timer_interface | ( | void | ) | const [virtual] |
Get only the reactor's timer related interface.
Definition at line 178 of file Event_Handler.cpp.
References ACE_TRACE, and reactor_.
Referenced by ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::timeout().
00179 { 00180 ACE_TRACE ("ACE_Event_Handler::reactor_timer_interface"); 00181 return this->reactor_; 00182 }
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 250 of file Event_Handler.cpp.
References ACE_STDIN, handle_close(), handle_input(), reactor(), and READ_MASK.
Referenced by register_stdin_handler().
00251 { 00252 ACE_Event_Handler *this_ptr = static_cast<ACE_Event_Handler *> (args); 00253 ACE_Reactor *r = this_ptr->reactor (); 00254 00255 while (this_ptr->handle_input (ACE_STDIN) != -1) 00256 continue; 00257 00258 this_ptr->handle_close (ACE_STDIN, ACE_Event_Handler::READ_MASK); 00259 // It's possible for handle_close() to "delete this" so we need to 00260 // cache the reactor pointer and use it here. 00261 r->notify (); 00262 00263 return 0; 00264 }
ACE_Event_Handler::Reference_Counting_Policy & ACE_Event_Handler::reference_counting_policy | ( | void | ) |
Current Reference_Counting_Policy.
Definition at line 242 of file Event_Handler.cpp.
References reference_counting_policy_.
Referenced by add_reference(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::cancel_type(), ACE_Select_Reactor_Notify::dispatch_notify(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::preinvoke(), remove_reference(), ACE_EH_Dispatch_Info::set(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::timeout(), and ACE_Select_Reactor_Handler_Repository::unbind().
00243 { 00244 return this->reference_counting_policy_; 00245 }
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 267 of file Event_Handler.cpp.
References ACE_STDIN, reactor(), read_adapter(), READ_MASK, ACE_Reactor::register_handler(), and ACE_Thread_Manager::spawn().
00271 { 00272 #if defined (ACE_WIN32) 00273 ACE_UNUSED_ARG (reactor); 00274 00275 eh->reactor (reactor); 00276 return thr_mgr->spawn (&read_adapter, static_cast<void *> (eh), flags); 00277 #else 00278 // Keep compilers happy. 00279 ACE_UNUSED_ARG (flags); 00280 ACE_UNUSED_ARG (thr_mgr); 00281 return reactor->register_handler (ACE_STDIN, 00282 eh, 00283 ACE_Event_Handler::READ_MASK); 00284 #endif /* ACE_WIN32 */ 00285 }
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.
Definition at line 198 of file Event_Handler.cpp.
References ACE_Event_Handler::Reference_Counting_Policy::ENABLED, reference_count_, reference_counting_policy(), and ACE_Event_Handler::Reference_Counting_Policy::value().
Referenced by ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::cancel_timer(), ACE_Select_Reactor_Notify::dispatch_notify(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle(), ACE_TP_Reactor::post_process_socket_event(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::postinvoke(), ACE_Notification_Queue::purge_pending_notifications(), ACE_Event_Handler_Handle_Timeout_Upcall< ACE_LOCK >::timeout(), ACE_Select_Reactor_Handler_Repository::unbind(), and ACE_Event_Handler_var::~ACE_Event_Handler_var().
00199 { 00200 bool const reference_counting_required = 00201 this->reference_counting_policy ().value () == 00202 ACE_Event_Handler::Reference_Counting_Policy::ENABLED; 00203 00204 if (reference_counting_required) 00205 { 00206 Reference_Count result = 00207 --this->reference_count_; 00208 00209 if (result == 0) 00210 delete this; 00211 00212 return result; 00213 } 00214 else 00215 { 00216 return 1; 00217 } 00218 }
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 288 of file Event_Handler.cpp.
References ACE_NOTSUP_RETURN, ACE_STDIN, reactor(), READ_MASK, and ACE_Reactor::remove_handler().
00290 { 00291 #if defined (ACE_WIN32) 00292 ACE_UNUSED_ARG (reactor); 00293 00294 // What should we do here? 00295 ACE_NOTSUP_RETURN (-1); 00296 #else 00297 return reactor->remove_handler (ACE_STDIN, 00298 ACE_Event_Handler::READ_MASK); 00299 #endif /* ACE_WIN32 */ 00300 }
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 themseleves.
Reimplemented in ACE_NonBlocking_Connect_Handler< SVC_HANDLER >.
Definition at line 139 of file Event_Handler.cpp.
References ACE_REACTOR_RESUMES_HANDLER, and ACE_TRACE.
Referenced by ACE_EH_Dispatch_Info::set().
00140 { 00141 ACE_TRACE ("ACE_Event_Handler::resume_handler"); 00142 00143 // Return a default value and allow the reactor to take care of 00144 // resuming the handler 00145 return ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER; 00146 }
void ACE_Event_Handler::set_handle | ( | ACE_HANDLE | ) | [virtual] |
Set the I/O handle.
Reimplemented in ACE_Svc_Handler<, >, and ACE_Svc_Handler< ACE_PEER_STREAM_2, ACE_SYNCH_USE >.
Definition at line 51 of file Event_Handler.cpp.
References ACE_TRACE.
00052 { 00053 ACE_TRACE ("ACE_Event_Handler::set_handle"); 00054 }
int ACE_Event_Handler::priority_ [private] |
Priority of this Event_Handler.
Definition at line 298 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, ACE_Connector< SVC_HANDLER, >, ACE_Name_Proxy, and ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.
Definition at line 301 of file Event_Handler.h.
Referenced by reactor(), and reactor_timer_interface().
Reference count.
Definition at line 293 of file Event_Handler.h.
Referenced by add_reference(), and remove_reference().
Reference counting requirements.
Definition at line 304 of file Event_Handler.h.
Referenced by reference_counting_policy().