ACE: ACE_Event_Handler class Reference

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   };

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     };

00035 {
00036   // ACE_TRACE ("ACE_Event_Handler::~ACE_Event_Handler");
00037 }

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 }

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 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

00179 {
00180   ACE_TRACE ("ACE_Event_Handler::reactor_timer_interface");
00181   return this->reactor_;
00182 }

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 }

00243 {
00244   return this->reference_counting_policy_;
00245 }

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 }

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 }

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 }

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 }

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


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

ACE_Event_Handler Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation