Reduced code in template class. Specialized ACE_Guard using lock-freed select_reactor_token

1 files changed, 189 insertions, 0 deletions

diff --git a/ace/Select_Reactor_Base.i b/ace/Select_Reactor_Base.i
index 001a19fb753..72070f841f9 100644
--- a/ace/Select_Reactor_Base.i
+++ b/ace/Select_Reactor_Base.i
@@ -71,6 +71,12 @@ ACE_Select_Reactor_Impl::ACE_Select_Reactor_Impl ()
 }
 
 ACE_INLINE int
+ACE_Select_Reactor_Impl::current_info (ACE_HANDLE, size_t &)
+{
+  return -1;
+}
+
+ACE_INLINE int
 ACE_Select_Reactor_Impl::supress_notify_renew (void)
 {
   return this->supress_renew_;
@@ -81,3 +87,186 @@ ACE_Select_Reactor_Impl::supress_notify_renew (int sr)
 {
   this->supress_renew_ = sr;
 }
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::resume_handler (ACE_Event_Handler *h)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::resume_handler");
+  return this->resume_handler (h->get_handle ());
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::suspend_handler (ACE_Event_Handler *h)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::suspend_handler");
+  return this->suspend_handler (h->get_handle ());
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::register_handler (int signum,
+                                           ACE_Event_Handler *new_sh,
+                                           ACE_Sig_Action *new_disp,
+                                           ACE_Event_Handler **old_sh,
+                                           ACE_Sig_Action *old_disp)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::register_handler");
+  return this->signal_handler_->register_handler (signum,
+						  new_sh, new_disp,
+						  old_sh, old_disp);
+}
+
+#if defined (ACE_WIN32)
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::register_handler (ACE_Event_Handler *event_handler,
+                                           ACE_HANDLE event_handle)
+{
+  // Don't have an implementation for this yet...
+  ACE_UNUSED_ARG (event_handler);
+  ACE_UNUSED_ARG (event_handle);
+  ACE_NOTSUP_RETURN (-1);
+}
+
+#endif /* ACE_WIN32 */
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::register_handler (ACE_HANDLE event_handle,
+                                           ACE_HANDLE io_handle,
+                                           ACE_Event_Handler *event_handler,
+                                           ACE_Reactor_Mask mask)
+{
+  // Don't have an implementation for this yet...
+  ACE_UNUSED_ARG (event_handle);
+  ACE_UNUSED_ARG (io_handle);
+  ACE_UNUSED_ARG (event_handler);
+  ACE_UNUSED_ARG (mask);
+  ACE_NOTSUP_RETURN (-1);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::handler (int signum, ACE_Event_Handler **handler)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::handler");
+  return this->handler_i (signum, handler);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::remove_handler (int signum,
+                                         ACE_Sig_Action *new_disp,
+                                         ACE_Sig_Action *old_disp,
+                                         int sigkey)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::remove_handler");
+  return this->signal_handler_->remove_handler (signum, new_disp, old_disp, sigkey);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::uses_event_associations (void)
+{
+  // Since the Select_Reactor does not do any event associations, this
+  // function always return 0.
+  return 0;
+}
+
+// = The remaining methods in this file must be called with locks
+// held.  Note the queue handles its own locking.
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::cancel_timer (ACE_Event_Handler *handler,
+                                       int dont_call_handle_close)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::cancel_timer");
+  return this->timer_queue_ != 0 &&
+    this->timer_queue_->cancel (handler, dont_call_handle_close);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::cancel_timer (long timer_id,
+                                       const void **arg,
+                                       int dont_call_handle_close)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::cancel_timer");
+  return this->timer_queue_->cancel (timer_id,
+				     arg,
+				     dont_call_handle_close);
+}
+
+// Performs operations on the "ready" bits.
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::ready_ops (ACE_Event_Handler *handler,
+                                    ACE_Reactor_Mask mask,
+                                    int ops)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::ready_ops");
+  return this->ready_ops (handler->get_handle (), mask, ops);
+}
+
+// Performs operations on the "dispatch" masks.
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::mask_ops (ACE_Event_Handler *handler,
+                                   ACE_Reactor_Mask mask,
+                                   int ops)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::mask_ops");
+  return this->mask_ops (handler->get_handle (), mask, ops);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::schedule_wakeup (ACE_Event_Handler *eh,
+                                          ACE_Reactor_Mask mask)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::schedule_wakeup");
+  return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::ADD_MASK);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::cancel_wakeup (ACE_Event_Handler *eh,
+                                        ACE_Reactor_Mask mask)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::cancel_wakeup");
+  return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::CLR_MASK);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::schedule_wakeup (ACE_HANDLE handle,
+                                          ACE_Reactor_Mask mask)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::schedule_wakeup");
+  return this->mask_ops (handle, mask, ACE_Reactor::ADD_MASK);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::cancel_wakeup (ACE_HANDLE handle,
+                                                               ACE_Reactor_Mask mask)
+{
+  ACE_TRACE ("ACE_Select_Reactor_Impl::cancel_wakeup");
+  return this->mask_ops (handle, mask, ACE_Reactor::CLR_MASK);
+}
+
+ACE_INLINE void
+ACE_Select_Reactor_Impl::wakeup_all_threads (void)
+{
+  // Send a notification, but don't block if there's no one to receive
+  // it.
+  this->notify (0, ACE_Event_Handler::NULL_MASK, (ACE_Time_Value *) &ACE_Time_Value::zero);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::alertable_handle_events (ACE_Time_Value *max_wait_time)
+{
+  return this->handle_events (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Select_Reactor_Impl::alertable_handle_events (ACE_Time_Value &max_wait_time)
+{
+  return this->handle_events (max_wait_time);
+}
+
+ACE_INLINE size_t
+ACE_Select_Reactor_Impl::size (void)
+{
+  return this->handler_rep_.size ();
+}