ACE/ace/Asynch_Pseudo_Task.cpp

   1 #include "ace/Asynch_Pseudo_Task.h"
   2
   3 #include "ace/OS_NS_errno.h"
   4 #include "ace/OS_NS_signal.h"
   5
   6 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   7
   8 ACE_Asynch_Pseudo_Task::ACE_Asynch_Pseudo_Task ()
   9   : select_reactor_ (),               // should be initialized before reactor_
  10     reactor_ (&select_reactor_, 0)    // don't delete implementation
  11 {
  12 }
  13
  14 ACE_Asynch_Pseudo_Task::~ACE_Asynch_Pseudo_Task ()
  15 {
  16   this->stop ();
  17 }
  18
  19 int
  20 ACE_Asynch_Pseudo_Task::start ()
  21 {
  22   if (this->reactor_.initialized () == 0)
  23     ACELIB_ERROR_RETURN ((LM_ERROR,
  24                        ACE_TEXT ("%N:%l:%p\n"),
  25                        ACE_TEXT ("start reactor is not initialized")),
  26                        -1);
  27
  28   return this->activate () == -1 ? -1 : 0;   // If started, return 0
  29 }
  30
  31 int
  32 ACE_Asynch_Pseudo_Task::stop ()
  33 {
  34   if (this->thr_count () == 0)  // already stopped
  35     return 0;
  36
  37   if (this->reactor_.end_reactor_event_loop () == -1)
  38     return -1;
  39
  40   this->wait ();
  41   this->reactor_.close ();
  42   return 0;
  43 }
  44
  45 int
  46 ACE_Asynch_Pseudo_Task::svc ()
  47 {
  48 #if !defined (ACE_WIN32)
  49
  50   sigset_t RT_signals;
  51
  52   sigemptyset (&RT_signals);
  53   for (int si = ACE_SIGRTMIN; si <= ACE_SIGRTMAX; si++)
  54     sigaddset (&RT_signals, si);
  55
  56   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &RT_signals, 0) != 0)
  57     ACELIB_ERROR ((LM_ERROR,
  58                 ACE_TEXT ("Error:(%P | %t):%p\n"),
  59                 ACE_TEXT ("pthread_sigmask")));
  60 #endif
  61
  62   reactor_.owner (ACE_Thread::self ());
  63   reactor_.run_reactor_event_loop ();
  64
  65   return 0;
  66 }
  67
  68
  69 int
  70 ACE_Asynch_Pseudo_Task::register_io_handler (ACE_HANDLE handle,
  71                                              ACE_Event_Handler *handler,
  72                                              ACE_Reactor_Mask mask,
  73                                              int flg_suspend)
  74 {
  75   // Register the handler with the reactor.
  76   if (-1 == this->reactor_.register_handler (handle, handler, mask))
  77     return -1;
  78
  79   if (flg_suspend == 0)
  80     return 0;
  81
  82   // Suspend the handle now. Enable only when the accept is issued
  83   // by the application.
  84   if (this->reactor_.suspend_handler (handle) == -1)
  85     {
  86       ACELIB_ERROR
  87         ((LM_ERROR,
  88           ACE_TEXT ("%N:%l:%p\n"),
  89           ACE_TEXT ("register_io_handler (suspended)")));
  90       this->reactor_.remove_handler (handle, ACE_Event_Handler::ALL_EVENTS_MASK
  91                                      | ACE_Event_Handler::DONT_CALL);
  92       return -1;
  93     }
  94
  95   return 0;
  96 }
  97
  98 int
  99 ACE_Asynch_Pseudo_Task::remove_io_handler (ACE_HANDLE handle)
 100 {
 101   return this->reactor_.remove_handler (handle,
 102                                         ACE_Event_Handler::ALL_EVENTS_MASK
 103                                         | ACE_Event_Handler::DONT_CALL);
 104 }
 105
 106 int
 107 ACE_Asynch_Pseudo_Task::remove_io_handler (ACE_Handle_Set &set)
 108 {
 109   return this->reactor_.remove_handler (set, ACE_Event_Handler::ALL_EVENTS_MASK
 110                                         | ACE_Event_Handler::DONT_CALL);
 111 }
 112
 113 int
 114 ACE_Asynch_Pseudo_Task::suspend_io_handler (ACE_HANDLE handle)
 115 {
 116   return this->reactor_.suspend_handler (handle);
 117 }
 118
 119 int
 120 ACE_Asynch_Pseudo_Task::resume_io_handler (ACE_HANDLE handle)
 121 {
 122   return this->reactor_.resume_handler (handle);
 123 }
 124
 125 ACE_END_VERSIONED_NAMESPACE_DECL