Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Asynch_Pseudo_Task Class Reference

#include <Asynch_Pseudo_Task.h>

Inheritance diagram for ACE_Asynch_Pseudo_Task:

Inheritance graph
[legend]
Collaboration diagram for ACE_Asynch_Pseudo_Task:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Asynch_Pseudo_Task ()
virtual ~ACE_Asynch_Pseudo_Task ()
int start (void)
int stop (void)
int register_io_handler (ACE_HANDLE handle, ACE_Event_Handler *handler, ACE_Reactor_Mask mask, int flg_suspend)
int remove_io_handler (ACE_HANDLE handle)
int remove_io_handler (ACE_Handle_Set &set)
int resume_io_handler (ACE_HANDLE handle)
int suspend_io_handler (ACE_HANDLE handle)

Protected Member Functions

virtual int svc (void)
 Run by a daemon thread to handle deferred processing.


Protected Attributes

ACE_Select_Reactor select_reactor_
ACE_Reactor reactor_
 Pointer to the various event demultiplexors.

Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Asynch_Pseudo_Task::ACE_Asynch_Pseudo_Task (   ) 
 

Definition at line 12 of file Asynch_Pseudo_Task.cpp. 

00013   : select_reactor_ (),               // should be initialized before reactor_
00014     reactor_ (&select_reactor_, 0)    // don't delete implementation
00015 {
00016 }

ACE_Asynch_Pseudo_Task::~ACE_Asynch_Pseudo_Task (   )  [virtual]
 

Definition at line 18 of file Asynch_Pseudo_Task.cpp.

References stop(). 

00019 {
00020   this->stop ();
00021 }

Member Function Documentation

int ACE_Asynch_Pseudo_Task::register_io_handler (  ACE_HANDLE  handle,
ACE_Event_Handler *  handler,
ACE_Reactor_Mask  mask,
int  flg_suspend
) 
 

Definition at line 75 of file Asynch_Pseudo_Task.cpp.

References ACE_ERROR, ACE_Reactor_Mask, ACE_TEXT, LM_ERROR, reactor_, ACE_Reactor::register_handler(), ACE_Reactor::remove_handler(), and ACE_Reactor::suspend_handler(). 

00079 {
00080   // Register the handler with the reactor.
00081   if (-1 == this->reactor_.register_handler (handle, handler, mask))
00082     return -1;
00083 
00084   if (flg_suspend == 0)
00085     return 0;
00086 
00087   // Suspend the handle now. Enable only when the accept is issued
00088   // by the application.
00089   if (this->reactor_.suspend_handler (handle) == -1)
00090     {
00091       ACE_ERROR
00092         ((LM_ERROR,
00093           ACE_TEXT ("%N:%l:%p\n"),
00094           ACE_TEXT ("register_io_handler (suspended)")));
00095       this->reactor_.remove_handler (handle, ACE_Event_Handler::ALL_EVENTS_MASK
00096                                      | ACE_Event_Handler::DONT_CALL);
00097       return -1;
00098     }
00099 
00100   return 0;
00101 }

int ACE_Asynch_Pseudo_Task::remove_io_handler (  ACE_Handle_Set &  set  ) 
 

Definition at line 112 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::remove_handler(). 

00113 {
00114   return this->reactor_.remove_handler (set, ACE_Event_Handler::ALL_EVENTS_MASK
00115                                         | ACE_Event_Handler::DONT_CALL);
00116 }

int ACE_Asynch_Pseudo_Task::remove_io_handler (  ACE_HANDLE  handle  ) 
 

Definition at line 104 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::remove_handler(). 

00105 {
00106   return this->reactor_.remove_handler (handle,
00107                                         ACE_Event_Handler::ALL_EVENTS_MASK
00108                                         | ACE_Event_Handler::DONT_CALL);
00109 }

int ACE_Asynch_Pseudo_Task::resume_io_handler (  ACE_HANDLE  handle  ) 
 

Definition at line 125 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::resume_handler(). 

00126 {
00127   return this->reactor_.resume_handler (handle);
00128 }

int ACE_Asynch_Pseudo_Task::start (  void   ) 
 

Definition at line 24 of file Asynch_Pseudo_Task.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_Task_Base::activate(), ACE_Reactor::initialized(), LM_ERROR, and reactor_. 

00025 {
00026   if (this->reactor_.initialized () == 0)
00027     ACE_ERROR_RETURN ((LM_ERROR,
00028                        ACE_TEXT ("%N:%l:%p\n"),
00029                        ACE_TEXT ("start reactor is not initialized")),
00030                        -1);
00031 
00032   return this->activate () == -1 ? -1 : 0;   // If started, return 0
00033 }

int ACE_Asynch_Pseudo_Task::stop (  void   ) 
 

Definition at line 36 of file Asynch_Pseudo_Task.cpp.

References ACE_Reactor::close(), ACE_Reactor::end_reactor_event_loop(), reactor_, ACE_Task_Base::thr_count(), and ACE_Task_Base::wait().

Referenced by ~ACE_Asynch_Pseudo_Task(). 

00037 {
00038   if (this->thr_count () == 0)  // already stopped
00039     return 0;
00040 
00041   if (this->reactor_.end_reactor_event_loop () == -1)
00042     return -1;
00043 
00044   this->wait ();
00045   this->reactor_.close ();
00046   return 0;
00047 }

int ACE_Asynch_Pseudo_Task::suspend_io_handler (  ACE_HANDLE  handle  ) 
 

Definition at line 119 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::suspend_handler(). 

00120 {
00121   return this->reactor_.suspend_handler (handle);
00122 }

int ACE_Asynch_Pseudo_Task::svc (  void   )  [protected, virtual]
 

Run by a daemon thread to handle deferred processing.

Reimplemented from ACE_Task_Base.

Definition at line 50 of file Asynch_Pseudo_Task.cpp.

References ACE_ERROR, ACE_SIGRTMAX, ACE_SIGRTMIN, ACE_TEXT, LM_ERROR, ACE_Reactor::owner(), ACE_OS::pthread_sigmask(), reactor_, ACE_Reactor::run_reactor_event_loop(), and SIG_BLOCK. 

00051 {
00052 #if !defined (ACE_WIN32)
00053 
00054   sigset_t RT_signals;
00055 
00056   sigemptyset (&RT_signals);
00057   for (int si = ACE_SIGRTMIN; si <= ACE_SIGRTMAX; si++)
00058     sigaddset (&RT_signals, si);
00059 
00060   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &RT_signals, 0) != 0)
00061     ACE_ERROR ((LM_ERROR,
00062                 ACE_TEXT ("Error:(%P | %t):%p\n"),
00063                 ACE_TEXT ("pthread_sigmask")));
00064 #endif
00065 
00066   reactor_.owner (ACE_Thread::self ());
00067   reactor_.run_reactor_event_loop ();
00068 
00069   return 0;
00070 }

Member Data Documentation

ACE_Reactor ACE_Asynch_Pseudo_Task::reactor_ [protected]
 

Pointer to the various event demultiplexors.

Reimplemented from ACE_Event_Handler.

Definition at line 65 of file Asynch_Pseudo_Task.h.

Referenced by register_io_handler(), remove_io_handler(), resume_io_handler(), start(), stop(), suspend_io_handler(), and svc().

ACE_Select_Reactor ACE_Asynch_Pseudo_Task::select_reactor_ [protected]
 

Definition at line 63 of file Asynch_Pseudo_Task.h.

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:54:01 2008 for ACE by doxygen 1.3.6