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_LIB_TEXT, ACE_Reactor_Mask, LM_ERROR, reactor_, ACE_Reactor::register_handler(), ACE_Reactor::remove_handler(), and ACE_Reactor::suspend_handler().

Referenced by ACE_WIN32_Asynch_Connect::connect(), ACE_POSIX_Asynch_Connect::connect(), and ACE_POSIX_Asynch_Accept::open(). 

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_LIB_TEXT ("%N:%l:%p\n"),
00094           ACE_LIB_TEXT ("register_io_handler (suspended)")));
00095       this->reactor_.remove_handler (handle,
00096                                      ACE_Event_Handler::ALL_EVENTS_MASK
00097                                      | ACE_Event_Handler::DONT_CALL);
00098       return -1;
00099     }
00100 
00101   return 0;
00102 }

int ACE_Asynch_Pseudo_Task::remove_io_handler (  ACE_Handle_Set &  set  ) 
 

Definition at line 113 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::remove_handler(). 

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

int ACE_Asynch_Pseudo_Task::remove_io_handler (  ACE_HANDLE  handle  ) 
 

Definition at line 105 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::remove_handler().

Referenced by ACE_WIN32_Asynch_Connect::cancel(), ACE_POSIX_Asynch_Connect::cancel(), ACE_WIN32_Asynch_Connect::close(), ACE_POSIX_Asynch_Connect::close(), ACE_POSIX_Asynch_Accept::close(), ACE_WIN32_Asynch_Connect::handle_close(), ACE_POSIX_Asynch_Connect::handle_close(), ACE_WIN32_Asynch_Connect::handle_output(), and ACE_POSIX_Asynch_Connect::handle_output(). 

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

int ACE_Asynch_Pseudo_Task::resume_io_handler (  ACE_HANDLE  handle  ) 
 

Definition at line 127 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::resume_handler().

Referenced by ACE_POSIX_Asynch_Accept::accept(). 

00128 {
00129   return this->reactor_.resume_handler (handle);
00130 }

int ACE_Asynch_Pseudo_Task::start (  void   ) 
 

Definition at line 24 of file Asynch_Pseudo_Task.cpp.

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

Referenced by ACE_POSIX_AIOCB_Proactor::ACE_POSIX_AIOCB_Proactor(), ACE_POSIX_CB_Proactor::ACE_POSIX_CB_Proactor(), and ACE_WIN32_Proactor::ACE_WIN32_Proactor(). 

00025 {
00026   if (this->reactor_.initialized () == 0)
00027     ACE_ERROR_RETURN ((LM_ERROR,
00028                        ACE_LIB_TEXT ("%N:%l:%p\n"),
00029                        ACE_LIB_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_POSIX_AIOCB_Proactor::close(), ~ACE_Asynch_Pseudo_Task(), and ACE_WIN32_Proactor::~ACE_WIN32_Proactor(). 

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 121 of file Asynch_Pseudo_Task.cpp.

References reactor_, and ACE_Reactor::suspend_handler().

Referenced by ACE_POSIX_Asynch_Accept::cancel(), and ACE_POSIX_Asynch_Accept::handle_input(). 

00122 {
00123   return this->reactor_.suspend_handler (handle);
00124 }

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_LIB_TEXT, ACE_SIGRTMAX, ACE_SIGRTMIN, 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_LIB_TEXT ("Error:(%P | %t):%p\n"),
00063                 ACE_LIB_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 Thu Nov 9 11:19:32 2006 for ACE by doxygen 1.3.6