ACE/ace/Select_Reactor_T.inl

   1 // -*- C++ -*-
   2 #include "ace/Reactor.h"
   3 #include "ace/Signal.h"
   4 #include "ace/Sig_Handler.h"
   5
   6 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   7
   8 template <class ACE_SELECT_REACTOR_TOKEN>
   9 ACE_INLINE int
  10 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::resume_handler (ACE_Event_Handler *h)
  11 {
  12   ACE_TRACE ("ACE_Select_Reactor_T::resume_handler");
  13   return this->resume_handler (h->get_handle ());
  14 }
  15
  16 template <class ACE_SELECT_REACTOR_TOKEN>
  17 ACE_INLINE int
  18 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::resume_handler (const ACE_Handle_Set &handles)
  19 {
  20   ACE_TRACE ("ACE_Select_Reactor_T::resume_handler");
  21   ACE_Handle_Set_Iterator handle_iter (handles);
  22   ACE_HANDLE h;
  23
  24   ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
  25
  26   while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
  27     if (this->resume_i (h) == -1)
  28       return -1;
  29
  30   return 0;
  31 }
  32
  33 template <class ACE_SELECT_REACTOR_TOKEN>
  34 ACE_INLINE int
  35 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::suspend_handler (ACE_Event_Handler *h)
  36 {
  37   ACE_TRACE ("ACE_Select_Reactor_T::suspend_handler");
  38   return this->suspend_handler (h->get_handle ());
  39 }
  40
  41 template <class ACE_SELECT_REACTOR_TOKEN>
  42 ACE_INLINE int
  43 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::suspend_handler (const ACE_Handle_Set &handles)
  44 {
  45   ACE_TRACE ("ACE_Select_Reactor_T::suspend_handler");
  46   ACE_Handle_Set_Iterator handle_iter (handles);
  47   ACE_HANDLE h;
  48
  49   ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
  50
  51   while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
  52     if (this->suspend_i (h) == -1)
  53       return -1;
  54
  55   return 0;
  56 }
  57
  58 template <class ACE_SELECT_REACTOR_TOKEN>
  59 ACE_INLINE int
  60 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler (int signum,
  61                                                                   ACE_Event_Handler *new_sh,
  62                                                                   ACE_Sig_Action *new_disp,
  63                                                                   ACE_Event_Handler **old_sh,
  64                                                                   ACE_Sig_Action *old_disp)
  65 {
  66   ACE_TRACE ("ACE_Select_Reactor_T::register_handler");
  67   return this->signal_handler_->register_handler (signum,
  68                                                   new_sh, new_disp,
  69                                                   old_sh, old_disp);
  70 }
  71
  72 #if defined (ACE_WIN32)
  73 template <class ACE_SELECT_REACTOR_TOKEN>
  74 ACE_INLINE int
  75 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler (ACE_Event_Handler *,
  76                                                                   ACE_HANDLE )
  77 {
  78   // Don't have an implementation for this yet...
  79   ACE_NOTSUP_RETURN (-1);
  80 }
  81 #endif /* ACE_WIN32 */
  82
  83 template <class ACE_SELECT_REACTOR_TOKEN>
  84 ACE_INLINE int
  85 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler (ACE_HANDLE ,
  86                                                                   ACE_HANDLE ,
  87                                                                   ACE_Event_Handler *,
  88                                                                   ACE_Reactor_Mask )
  89 {
  90   // Don't have an implementation for this yet...
  91   ACE_NOTSUP_RETURN (-1);
  92 }
  93
  94 template <class ACE_SELECT_REACTOR_TOKEN>
  95 ACE_INLINE int
  96 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handler (int signum, ACE_Event_Handler **handler)
  97 {
  98   ACE_TRACE ("ACE_Select_Reactor_T::handler");
  99   return this->handler_i (signum, handler);
 100 }
 101
 102 template <class ACE_SELECT_REACTOR_TOKEN>
 103 ACE_INLINE int
 104 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler (int signum,
 105                                                                 ACE_Sig_Action *new_disp,
 106                                                                 ACE_Sig_Action *old_disp,
 107                                                                 int sigkey)
 108 {
 109   ACE_TRACE ("ACE_Select_Reactor_T::remove_handler");
 110   return this->signal_handler_->remove_handler (signum, new_disp, old_disp, sigkey);
 111 }
 112
 113 template <class ACE_SELECT_REACTOR_TOKEN>
 114 ACE_INLINE bool
 115 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::uses_event_associations ()
 116 {
 117   // Since the Select_Reactor does not do any event associations, this
 118   // function always return false.
 119   return false;
 120 }
 121
 122 // = The remaining methods in this file must be called with locks
 123 // held.
 124
 125 // Performs operations on the "ready" bits.
 126
 127 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 128 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::ready_ops (ACE_Event_Handler *handler,
 129                                                            ACE_Reactor_Mask mask,
 130                                                            int ops)
 131 {
 132   ACE_TRACE ("ACE_Select_Reactor_T::ready_ops");
 133   return this->ready_ops (handler->get_handle (), mask, ops);
 134 }
 135
 136 // Performs operations on the "dispatch" masks.
 137
 138 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 139 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::mask_ops (ACE_Event_Handler *handler,
 140                                                           ACE_Reactor_Mask mask,
 141                                                           int ops)
 142 {
 143   ACE_TRACE ("ACE_Select_Reactor_T::mask_ops");
 144   return this->mask_ops (handler->get_handle (), mask, ops);
 145 }
 146
 147 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 148 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::schedule_wakeup (ACE_Event_Handler *eh,
 149                                                                  ACE_Reactor_Mask mask)
 150 {
 151   ACE_TRACE ("ACE_Select_Reactor_T::schedule_wakeup");
 152   return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::ADD_MASK);
 153 }
 154
 155 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 156 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::cancel_wakeup (ACE_Event_Handler *eh,
 157                                                                ACE_Reactor_Mask mask)
 158 {
 159   ACE_TRACE ("ACE_Select_Reactor_T::cancel_wakeup");
 160   return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::CLR_MASK);
 161 }
 162
 163 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 164 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::schedule_wakeup (ACE_HANDLE handle,
 165                                                                  ACE_Reactor_Mask mask)
 166 {
 167   ACE_TRACE ("ACE_Select_Reactor_T::schedule_wakeup");
 168   return this->mask_ops (handle, mask, ACE_Reactor::ADD_MASK);
 169 }
 170
 171 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 172 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::cancel_wakeup (ACE_HANDLE handle,
 173                                                                ACE_Reactor_Mask mask)
 174 {
 175   ACE_TRACE ("ACE_Select_Reactor_T::cancel_wakeup");
 176   return this->mask_ops (handle, mask, ACE_Reactor::CLR_MASK);
 177 }
 178
 179 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE ACE_Lock &
 180 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::lock ()
 181 {
 182   ACE_TRACE ("ACE_Select_Reactor_T::lock");
 183   return this->lock_adapter_;
 184 }
 185
 186 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE void
 187 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::wakeup_all_threads ()
 188 {
 189   // Send a notification, but don't block if there's no one to receive
 190   // it.
 191   this->notify (0, ACE_Event_Handler::NULL_MASK, (ACE_Time_Value *) &ACE_Time_Value::zero);
 192 }
 193
 194 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 195 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::alertable_handle_events (ACE_Time_Value *max_wait_time)
 196 {
 197   return this->handle_events (max_wait_time);
 198 }
 199
 200 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 201 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::alertable_handle_events (ACE_Time_Value &max_wait_time)
 202 {
 203   return this->handle_events (max_wait_time);
 204 }
 205
 206 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE int
 207 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::deactivated ()
 208 {
 209   return this->deactivated_;
 210 }
 211
 212 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE void
 213 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::deactivate (int do_stop)
 214 {
 215   {
 216     ACE_MT (ACE_GUARD (ACE_SELECT_REACTOR_TOKEN,
 217                        ace_mon,
 218                        this->token_));
 219     this->deactivated_ = static_cast<sig_atomic_t> (do_stop);
 220   }
 221
 222   this->wakeup_all_threads ();
 223 }
 224
 225 template <class ACE_SELECT_REACTOR_TOKEN> ACE_INLINE size_t
 226 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::size () const
 227 {
 228   return this->handler_rep_.size ();
 229 }
 230
 231 ACE_END_VERSIONED_NAMESPACE_DECL