Revert previous change.

1 files changed, 0 insertions, 629 deletions

diff --git a/ace/Select_Reactor_Base.cpp b/ace/Select_Reactor_Base.cpp
index 52f3aded471..4f133a4702a 100644
--- a/ace/Select_Reactor_Base.cpp
+++ b/ace/Select_Reactor_Base.cpp
@@ -749,632 +749,3 @@ ACE_Select_Reactor_Impl::bit_ops (ACE_HANDLE handle,
     }
   return omask;
 }
-
-int
-ACE_Select_Reactor_Impl::any_ready (ACE_Select_Reactor_Handle_Set &wait_set)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::fill_in_ready");
-
-#if !defined (ACE_WIN32)
-  // Make this call signal safe.
-  ACE_Sig_Guard sb;
-#endif /* ACE_WIN32 */
-
-  int number_ready = this->ready_set_.rd_mask_.num_set ()
-    + this->ready_set_.wr_mask_.num_set ()
-    + this->ready_set_.ex_mask_.num_set ();
-
-  if (number_ready > 0)
-    {
-      wait_set.rd_mask_ = this->ready_set_.rd_mask_;
-      wait_set.wr_mask_ = this->ready_set_.wr_mask_;
-      wait_set.ex_mask_ = this->ready_set_.ex_mask_;
-
-      this->ready_set_.rd_mask_.reset ();
-      this->ready_set_.wr_mask_.reset ();
-      this->ready_set_.ex_mask_.reset ();
-    }
-
-  return number_ready;
-}
-
-int
-ACE_Select_Reactor_Impl::handler_i (int signum, ACE_Event_Handler **eh)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::handler_i");
-  ACE_Event_Handler *handler = this->signal_handler_->handler (signum);
-
-  if (handler == 0)
-    return -1;
-  else if (*eh != 0)
-    *eh = handler;
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::notify (ACE_Event_Handler *eh,
-                                 ACE_Reactor_Mask mask,
-                                 ACE_Time_Value *timeout)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::notify");
-
-  ssize_t n = 0;
-
-  // Pass over both the Event_Handler *and* the mask to allow the
-  // caller to dictate which Event_Handler method the receiver
-  // invokes.  Note that this call can timeout.
-
-  n = this->notify_handler_->notify (eh, mask, timeout);
-  return n == -1 ? -1 : 0;
-}
-
-int
-ACE_Select_Reactor_Impl::set_sig_handler (ACE_Sig_Handler *signal_handler)
-{
-  if (this->signal_handler_ != 0 && this->delete_signal_handler_ != 0)
-    delete this->signal_handler_;
-  this->signal_handler_ = signal_handler;
-  this->delete_signal_handler_ = 0;
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::set_timer_queue (ACE_Timer_Queue *timer_queue)
-{
-  if (this->timer_queue_ != 0 && this->delete_timer_queue_ != 0)
-    delete this->timer_queue_;
-  this->timer_queue_ = timer_queue;
-  this->delete_timer_queue_ = 0;
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::remove_handler_i (const ACE_Handle_Set &handles,
-                                           ACE_Reactor_Mask mask)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::remove_handler_i");
-  ACE_HANDLE h;
-
-  ACE_Handle_Set_Iterator handle_iter (handles);
-
-  while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
-    if (this->remove_handler_i (h, mask) == -1)
-      return -1;
-
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::register_handler_i (const ACE_Handle_Set &handles,
-                                             ACE_Event_Handler *handler,
-                                             ACE_Reactor_Mask mask)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::register_handler_i");
-  ACE_HANDLE h;
-
-  ACE_Handle_Set_Iterator handle_iter (handles);
-  while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
-    if (this->register_handler_i (h, handler, mask) == -1)
-      return -1;
-
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::register_handler (const ACE_Sig_Set &sigset,
-                                           ACE_Event_Handler *new_sh,
-                                           ACE_Sig_Action *new_disp)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::register_handler");
-
-  int result = 0;
-
-#if (ACE_NSIG > 0)
-  for (int s = 1; s < ACE_NSIG; s++)
-    if (sigset.is_member (s)
-        && this->signal_handler_->register_handler (s, new_sh,
-                                                    new_disp) == -1)
-      result = -1;
-#else
-  ACE_UNUSED_ARG (sigset);
-  ACE_UNUSED_ARG (new_sh);
-  ACE_UNUSED_ARG (new_disp);
-#endif /* ACE_NSIG */
-  return result;
-}
-
-int
-ACE_Select_Reactor_Impl::remove_handler (const ACE_Sig_Set &sigset)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::remove_handler");
-  int result = 0;
-
-#if (ACE_NSIG > 0)
-  for (int s = 1; s < ACE_NSIG; s++)
-    if (sigset.is_member (s)
-        && this->signal_handler_->remove_handler (s) == -1)
-      result = -1;
-#else
-  ACE_UNUSED_ARG (sigset);
-#endif /* ACE_NSIG */
-
-  return result;
-}
-
-// Main event loop driver that blocks for <max_wait_time> before
-// returning (will return earlier if I/O or signal events occur).
-
-int
-ACE_Select_Reactor_Impl::handle_events (ACE_Time_Value &max_wait_time)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::handle_events");
-
-  return this->handle_events (&max_wait_time);
-}
-
-int
-ACE_Select_Reactor_Impl::handle_error (void)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::handle_error");
-  if (errno == EINTR)
-    return this->restart_;
-#if defined (__MVS__)
-  // On MVS Open Edition, there can be a number of failure codes on a bad
-  // socket, so check_handles on anything other than EINTR.
-  else
-    return this->check_handles ();
-#else
-  else if (errno == EBADF)
-    return this->check_handles ();
-  else
-    return -1;
-#endif  /* __MVS__ */
-}
-
-void
-ACE_Select_Reactor_Impl::notify_handle (ACE_HANDLE handle,
-                                        ACE_Reactor_Mask mask,
-                                        ACE_Handle_Set &ready_mask,
-                                        ACE_Event_Handler *event_handler,
-                                        ACE_EH_PTMF ptmf)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::notify_handle");
-  // Check for removed handlers.
-  if (event_handler == 0)
-    return;
-
-  int status = (event_handler->*ptmf) (handle);
-
-  if (status < 0)
-    this->remove_handler_i (handle, mask);
-  else if (status > 0)
-    ready_mask.set_bit (handle);
-}
-
-// Must be called with locks held.
-
-int
-ACE_Select_Reactor_Impl::handler_i (ACE_HANDLE handle,
-                                    ACE_Reactor_Mask mask,
-                                    ACE_Event_Handler **handler)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::handler_i");
-  ACE_Event_Handler *h = this->handler_rep_.find (handle);
-
-  if (h == 0)
-    return -1;
-  else
-    {
-      if ((ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)
-           || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK))
-          && this->wait_set_.rd_mask_.is_set (handle) == 0)
-        return -1;
-      if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)
-          && this->wait_set_.wr_mask_.is_set (handle) == 0)
-        return -1;
-      if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)
-          && this->wait_set_.ex_mask_.is_set (handle) == 0)
-        return -1;
-    }
-
-  if (handler != 0)
-    *handler = h;
-  return 0;
-}
-
-// Must be called with locks held
-
-int
-ACE_Select_Reactor_Impl::resume_i (ACE_HANDLE handle)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::resume");
-  if (this->handler_rep_.find (handle) == 0)
-    return -1;
-
-  if (this->suspend_set_.rd_mask_.is_set (handle))
-    {
-      this->wait_set_.rd_mask_.set_bit (handle);
-      this->suspend_set_.rd_mask_.clr_bit (handle);
-    }
-  if (this->suspend_set_.wr_mask_.is_set (handle))
-    {
-      this->wait_set_.wr_mask_.set_bit (handle);
-      this->suspend_set_.wr_mask_.clr_bit (handle);
-    }
-  if (this->suspend_set_.ex_mask_.is_set (handle))
-    {
-      this->wait_set_.ex_mask_.set_bit (handle);
-      this->suspend_set_.ex_mask_.clr_bit (handle);
-    }
-  return 0;
-}
-
-// Must be called with locks held
-
-int
-ACE_Select_Reactor_Impl::suspend_i (ACE_HANDLE handle)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::suspend");
-  if (this->handler_rep_.find (handle) == 0)
-    return -1;
-
-  if (this->wait_set_.rd_mask_.is_set (handle))
-    {
-      this->suspend_set_.rd_mask_.set_bit (handle);
-      this->wait_set_.rd_mask_.clr_bit (handle);
-    }
-  if (this->wait_set_.wr_mask_.is_set (handle))
-    {
-      this->suspend_set_.wr_mask_.set_bit (handle);
-      this->wait_set_.wr_mask_.clr_bit (handle);
-    }
-  if (this->wait_set_.ex_mask_.is_set (handle))
-    {
-      this->suspend_set_.ex_mask_.set_bit (handle);
-      this->wait_set_.ex_mask_.clr_bit (handle);
-    }
-  return 0;
-}
-
-// Must be called with locks held
-
-int
-ACE_Select_Reactor_Impl::register_handler_i (ACE_HANDLE handle,
-                                             ACE_Event_Handler *event_handler,
-                                             ACE_Reactor_Mask mask)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::register_handler_i");
-
-  // Insert the <handle, event_handle> tuple into the Handler
-  // Repository.
-  return this->handler_rep_.bind (handle, event_handler, mask);
-}
-
-int
-ACE_Select_Reactor_Impl::remove_handler_i (ACE_HANDLE handle,
-                                           ACE_Reactor_Mask mask)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::remove_handler_i");
-
-  // Unbind this handle.
-  return this->handler_rep_.unbind (handle, mask);
-}
-
-// Must be called with lock held.
-
-int
-ACE_Select_Reactor_Impl::wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &dispatch_set,
-                                                   ACE_Time_Value *max_wait_time)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::wait_for_multiple_events");
-  u_long width = 0;
-  ACE_Time_Value timer_buf (0);
-  ACE_Time_Value *this_timeout = &timer_buf;
-
-  int number_of_active_handles = this->any_ready (dispatch_set);
-
-  // If there are any bits enabled in the <ready_set_> then we'll
-  // handle those first, otherwise we'll block in select().
-
-  if (number_of_active_handles == 0)
-    {
-      do
-        {
-          if (this->timer_queue_->calculate_timeout (max_wait_time,
-                                                     this_timeout) == 0)
-            this_timeout = 0;
-
-          width = (u_long) this->handler_rep_.max_handlep1 ();
-
-          dispatch_set.rd_mask_ = this->wait_set_.rd_mask_;
-          dispatch_set.wr_mask_ = this->wait_set_.wr_mask_;
-          dispatch_set.ex_mask_ = this->wait_set_.ex_mask_;
-
-          number_of_active_handles = ACE_OS::select (int (width),
-                                                     dispatch_set.rd_mask_,
-                                                     dispatch_set.wr_mask_,
-                                                     dispatch_set.ex_mask_,
-                                                     this_timeout);
-        }
-      while (number_of_active_handles == -1 && this->handle_error () > 0);
-
-      // @@ Remove?!
-      if (number_of_active_handles > 0)
-        {
-#if !defined (ACE_WIN32)
-          dispatch_set.rd_mask_.sync (this->handler_rep_.max_handlep1 ());
-          dispatch_set.wr_mask_.sync (this->handler_rep_.max_handlep1 ());
-          dispatch_set.ex_mask_.sync (this->handler_rep_.max_handlep1 ());
-#endif /* ACE_WIN32 */
-        }
-    }
-
-  // Return the number of events to dispatch.
-  return number_of_active_handles;
-}
-
-int
-ACE_Select_Reactor_Impl::dispatch_timer_handlers (void)
-{
-  int number_dispatched = this->timer_queue_->expire ();
-  return this->state_changed_ ? -1 : number_dispatched;
-}
-
-int
-ACE_Select_Reactor_Impl::dispatch_notification_handlers (int &number_of_active_handles,
-                                                         ACE_Select_Reactor_Handle_Set &dispatch_set)
-{
-#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-  // Check to see if the ACE_HANDLE associated with the
-  // Select_Reactor's notify hook is enabled.  If so, it means that
-  // one or more other threads are trying to update the
-  // ACE_Select_Reactor_T's internal tables.  We'll handle all these
-  // threads and then break out to continue the event loop.
-
-  int number_dispatched =
-    this->notify_handler_->dispatch_notifications (number_of_active_handles,
-                                                   dispatch_set.rd_mask_);
-  return this->state_changed_ ? -1 : number_dispatched;
-#else
-  ACE_UNUSED_ARG (number_of_active_handles);
-  ACE_UNUSED_ARG (dispatch_set);
-  return 0;
-#endif /* ACE_MT_SAFE */
-}
-
-int
-ACE_Select_Reactor_Impl::dispatch_io_set (int number_of_active_handles,
-                                          int& number_dispatched,
-                                          int mask,
-                                          ACE_Handle_Set& dispatch_mask,
-                                          ACE_Handle_Set& ready_mask,
-                                          ACE_EH_PTMF callback)
-{
-  ACE_HANDLE handle;
-
-  ACE_Handle_Set_Iterator handle_iter (dispatch_mask);
-
-  while ((handle = handle_iter ()) != ACE_INVALID_HANDLE
-         && number_dispatched < number_of_active_handles
-         && this->state_changed_ == 0)
-    {
-      // ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Select_Reactor_T::dispatching\n")));
-      number_dispatched++;
-      this->notify_handle (handle,
-                           mask,
-                           ready_mask,
-                           this->handler_rep_.find (handle),
-                           callback);
-    }
-
-  if (number_dispatched > 0 && this->state_changed_)
-    {
-      return -1;
-    }
-
-  return 0;
-}
-
-int
-ACE_Select_Reactor_Impl::dispatch_io_handlers (int &number_of_active_handles,
-                                               ACE_Select_Reactor_Handle_Set &dispatch_set)
-{
-  int number_dispatched = 0;
-
-  // Handle output events (this code needs to come first to handle
-  // the obscure case of piggy-backed data coming along with the
-  // final handshake message of a nonblocking connection).
-
-  // ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Select_Reactor_T::dispatch - WRITE\n")));
-  if (this->dispatch_io_set (number_of_active_handles,
-                             number_dispatched,
-                             ACE_Event_Handler::WRITE_MASK,
-                             dispatch_set.wr_mask_,
-                             this->ready_set_.wr_mask_,
-                             &ACE_Event_Handler::handle_output) == -1)
-    {
-      number_of_active_handles -= number_dispatched;
-      return -1;
-    }
-
-
-  // ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Select_Reactor_Impl::dispatch - EXCEPT\n")));
-  if (this->dispatch_io_set (number_of_active_handles,
-                             number_dispatched,
-                             ACE_Event_Handler::EXCEPT_MASK,
-                             dispatch_set.ex_mask_,
-                             this->ready_set_.ex_mask_,
-                             &ACE_Event_Handler::handle_exception) == -1)
-    {
-      number_of_active_handles -= number_dispatched;
-      return -1;
-    }
-
-  // ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Select_Reactor_Impl::dispatch - READ\n")));
-  if (this->dispatch_io_set (number_of_active_handles,
-                             number_dispatched,
-                             ACE_Event_Handler::READ_MASK,
-                             dispatch_set.rd_mask_,
-                             this->ready_set_.rd_mask_,
-                             &ACE_Event_Handler::handle_input) == -1)
-    {
-      number_of_active_handles -= number_dispatched;
-      return -1;
-    }
-
-  number_of_active_handles -= number_dispatched;
-  return number_dispatched;
-}
-
-int
-ACE_Select_Reactor_Impl::dispatch (int number_of_active_handles,
-                                   ACE_Select_Reactor_Handle_Set &dispatch_set)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::dispatch");
-
-  // The following do/while loop keeps dispatching as long as there
-  // are still active handles.  Note that the only way we should ever
-  // iterate more than once through this loop is if signals occur
-  // while we're dispatching other handlers.
-
-  do
-    {
-      // Note that we keep track of changes to our state.  If any of
-      // the dispatch_*() methods below return -1 it means that the
-      // <wait_set_> state has changed as the result of an
-      // <ACE_Event_Handler> being dispatched.  This means that we
-      // need to bail out and rerun the select() loop since our
-      // existing notion of handles in <dispatch_set> may no longer be
-      // correct.
-      //
-      // In the beginning, our state starts out unchanged.  After
-      // every iteration (i.e., due to signals), our state starts out
-      // unchanged again.
-
-      this->state_changed_ = 0;
-
-      // Perform the Template Method for dispatching all the handlers.
-
-      // Handle timers first since they may have higher latency
-      // constraints.
-
-      if (this->dispatch_timer_handlers () == -1)
-        // State has changed or timer queue has failed, exit inner
-        // loop.
-        break;
-
-      else if (number_of_active_handles <= 0)
-        // Bail out since we got here since select() was interrupted.
-        {
-          if (ACE_Sig_Handler::sig_pending () != 0)
-            {
-              ACE_Sig_Handler::sig_pending (0);
-
-              // If any HANDLES in the <ready_set_> are activated as a
-              // result of signals they should be dispatched since
-              // they may be time critical...
-              number_of_active_handles = this->any_ready (dispatch_set);
-            }
-          else
-            return number_of_active_handles;
-        }
-
-      // Next dispatch the notification handlers (if there are any to
-      // dispatch).  These are required to handle multi-threads that
-      // are trying to update the <Reactor>.
-
-      else if (this->dispatch_notification_handlers (number_of_active_handles,
-                                                     dispatch_set) == -1)
-        break; // State has changed, exit inner loop.
-
-      // Finally, dispatch the I/O handlers.
-      else if (this->dispatch_io_handlers (number_of_active_handles,
-                                           dispatch_set) == -1)
-        // State has changed, so exit the inner loop.
-        break;
-    }
-  while (number_of_active_handles > 0);
-
-  return 1;
-}
-
-int
-ACE_Select_Reactor_Impl::handle_events_i (ACE_Time_Value *max_wait_time)
-{
-  int result = -1;
-
-  ACE_SEH_TRY {
-    ACE_Select_Reactor_Handle_Set dispatch_set;
-
-    int number_of_active_handles =
-      this->wait_for_multiple_events (dispatch_set,
-                                      max_wait_time);
-
-    result = this->dispatch (number_of_active_handles, dispatch_set);
-  }
-  ACE_SEH_EXCEPT (this->release_token ()) {
-    // As it stands now, we catch and then rethrow all Win32
-    // structured exceptions so that we can make sure to release the
-    // <token_> lock correctly.
-  }
-
-  this->state_changed_ = 1;
-
-  return result;
-}
-
-int
-ACE_Select_Reactor_Impl::check_handles (void)
-{
-  ACE_TRACE ("ACE_Select_Reactor_Impl::check_handles");
-
-#if defined (ACE_WIN32) || defined (__MVS__)
-  ACE_Time_Value time_poll = ACE_Time_Value::zero;
-  ACE_Handle_Set rd_mask;
-#endif /* ACE_WIN32 || MVS */
-
-  ACE_Event_Handler *eh = 0;
-  int result = 0;
-
-  for (ACE_Select_Reactor_Handler_Repository_Iterator iter (&this->handler_rep_);
-       iter.next (eh) != 0;
-       iter.advance ())
-    {
-      ACE_HANDLE handle = eh->get_handle ();
-
-      // Skip back to the beginning of the loop if the HANDLE is
-      // invalid.
-      if (handle == ACE_INVALID_HANDLE)
-        continue;
-
-#if defined (ACE_WIN32) || defined (__MVS__)
-      // Win32 needs to do the check this way because fstat won't work on
-      // a socket handle.  MVS Open Edition needs to do it this way because,
-      // even though the docs say to check a handle with either select or
-      // fstat, the fstat method always says the handle is ok.
-      rd_mask.set_bit (handle);
-
-      if (ACE_OS::select (int (handle) + 1,
-                          rd_mask, 0, 0,
-                          &time_poll) < 0)
-        {
-          result = 1;
-          this->remove_handler_i (handle,
-                                  ACE_Event_Handler::ALL_EVENTS_MASK);
-        }
-      rd_mask.clr_bit (handle);
-#else /* !ACE_WIN32 && !MVS */
-      struct stat temp;
-
-      if (ACE_OS::fstat (handle, &temp) == -1)
-        {
-          result = 1;
-          this->remove_handler_i (handle,
-                                  ACE_Event_Handler::ALL_EVENTS_MASK);
-        }
-#endif /* ACE_WIN32 || MVS */
-    }
-
-  return result;
-}
-