Templatized Select_Reactor

1 files changed, 6 insertions, 937 deletions

diff --git a/ace/Select_Reactor.h b/ace/Select_Reactor.h
index a43c64c60b5..bc78ad28b15 100644
--- a/ace/Select_Reactor.h
+++ b/ace/Select_Reactor.h
@@ -17,951 +17,20 @@
 #if !defined (ACE_SELECT_REACTOR_H)
 #define ACE_SELECT_REACTOR_H
 
-#include "ace/Signal.h"
-#include "ace/Timer_Queue.h"
-#include "ace/Event_Handler.h"
-#include "ace/Handle_Set.h"
-#include "ace/Token.h"
-#include "ace/Pipe.h"
-#include "ace/Reactor_Impl.h"
-
-// Add useful typedefs to simplify the following code.
-typedef void (ACE_Handle_Set::*ACE_FDS_PTMF) (ACE_HANDLE);
-typedef int (ACE_Event_Handler::*ACE_EH_PTMF) (ACE_HANDLE);
-
-// Forward declaration.
-class ACE_Select_Reactor;
-
-class ACE_Export ACE_Select_Reactor_Handle_Set
-{
-  // = TITLE
-  //      Track handles we are interested for various events.
-public:
-  ACE_Handle_Set rd_mask_;
-  // Read events (e.g., input pending, accept pending).
-
-  ACE_Handle_Set wr_mask_;
-  // Write events (e.g., flow control abated, non-blocking connection
-  // complete).
-
-  ACE_Handle_Set ex_mask_;
-  // Exception events (e.g., SIG_URG).
-};
+#include "ace/Select_Reactor_T.h"
 
 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-
 #if defined (ACE_SELECT_REACTOR_HAS_DEADLOCK_DETECTION)
 #include "ace/Local_Tokens.h"
-typedef ACE_Local_Mutex ACE_SELECT_REACTOR_MUTEX;
+typedef ACE_Select_Reactor_Token_T<ACE_Local_Mutex> ACE_Select_Reactor_Token;
 #else
-typedef ACE_Token ACE_SELECT_REACTOR_MUTEX;
+typedef ACE_Select_Reactor_Token_T<ACE_Token> ACE_Select_Reactor_Token;
 #endif /* ACE_SELECT_REACTOR_HAS_DEADLOCK_DETECTION */
-
-class ACE_Export ACE_Select_Reactor_Token : public ACE_SELECT_REACTOR_MUTEX
-{
-  // = TITLE
-  //     Used as a synchronization mechanism to coordinate concurrent
-  //     access to a Select_Reactor object.
-  //
-  // = DESCRIPTION
-  //     This class is used to make the <ACE_Select_Reactor>
-  //     thread-safe. By default, the thread that runs the
-  //     <handle_events> loop holds the token, even when it is blocked
-  //     in the <select> call.  Whenever another thread wants to
-  //     access the <ACE_Reactor> via its <register_handler>,
-  //     <remove_handler>, etc. methods) it must ask the token owner
-  //     for temporary release of the token.  To accomplish this, the
-  //     owner of a token must define a <sleep_hook> through which it
-  //     can be notified to temporarily release the token if the
-  //     current situation permits this.  
-  //
-  //     The owner of the token is responsible for deciding which
-  //     request for the token can be granted.  By using the
-  //     <ACE_Token::renew> API, the thread that releases the token
-  //     temporarily can specify to get the token back right after the
-  //     other thread has completed using the token.  Thus, there is a
-  //     dedicated thread that owns the token ``by default.''  This
-  //     thread grants other threads access to the token by ensuring
-  //     that whenever somebody else has finished using the token the
-  //     ``default owner'' first holds the token again, i.e., the
-  //     owner has the chance to schedule other threads.  
-  //
-  //     The thread that most likely needs the token most of the time
-  //     is the thread running the dispatch loop.  Typically the token
-  //     gets released prior to entering the <select> call and gets
-  //     ``re-acquired'' as soon as the <select> call returns, which
-  //     results probably in many calls to <release>/<acquire> that
-  //     are not really needed since no other thread would need the
-  //     token in the meantime.  That's why the dispatcher thread is
-  //     chosen to be the owner of the token.
-  //
-  //     In case the token would have been released while in <select>
-  //     there would be a good chance that the <fd_set> could have
-  //     been modified while the <select> returns from blocking and
-  //     trying to re-acquire the lock.  Through the token mechanism
-  //     it is ensured that while another thread is holding the token,
-  //     the dispatcher thread is blocked in the <renew> call and not
-  //     in <select>.  Thus, it is not critical to change the
-  //     <fd_set>.  The implementation of the <sleep_hook> mechanism
-  //     provided by the <ACE_Select_Reactor_Token> enables the
-  //     default owner to be the thread that executes the dispatch
-  //     loop.
-public:
-  ACE_Select_Reactor_Token (ACE_Select_Reactor &r);
-  ACE_Select_Reactor_Token (void);
-  virtual ~ACE_Select_Reactor_Token (void);
-
-  virtual void sleep_hook (void);
-  // Called just before the ACE_Event_Handler goes to sleep.
-
-  ACE_Select_Reactor &select_reactor (void);
-  void select_reactor (ACE_Select_Reactor &);
-  // Set/Get methods
-
-  virtual void dump (void) const;
-  // Dump the state of an object.
-
-  ACE_ALLOC_HOOK_DECLARE;
-  // Declare the dynamic allocation hooks.
-
-private:
-  ACE_Select_Reactor *select_reactor_;
-};
 #else
-// If we're non-MT safe then this is just a no-op...
-typedef ACE_Null_Mutex ACE_Select_Reactor_Token;
-#endif /* ACE_MT_SAFE */
-
-class ACE_Export ACE_Event_Tuple
-{
-  // = TITLE
-  //     An ACE_Event_Handler and its associated ACE_HANDLE.
-  //
-  // = DESCRIPTION
-  //     One ACE_Event_Handler is registered for one or more
-  //     ACE_HANDLE, in some points this information must be stored
-  //     explicitly. This structure provides a lightweight mechanism
-  //     to do so.
-public:
-  ACE_Event_Tuple (void);
-  ACE_Event_Tuple (ACE_Event_Handler* eh, ACE_HANDLE h);
-  ~ACE_Event_Tuple (void);
-
-  int operator== (const ACE_Event_Tuple &rhs) const;
-  // Equality operator.
-
-  int operator!= (const ACE_Event_Tuple &rhs) const;
-  // Inequality operator.
-
-  ACE_HANDLE handle_;
-  ACE_Event_Handler* event_handler_;
-};
-
-class ACE_Export ACE_Select_Reactor_Notify : public ACE_Reactor_Notify
-{
-  // = TITLE
-  //     Unblock the <ACE_Select_Reactor> from its event loop.
-  //
-  // = DESCRIPTION
-  //     This implementation is necessary for cases where the
-  //     <ACE_Select_Reactor> is run in a multi-threaded program.  In
-  //     this case, we need to be able to unblock select() or poll()
-  //     when updates occur other than in the main
-  //     <ACE_Select_Reactor> thread.  To do this, we signal an
-  //     auto-reset event the <ACE_Select_Reactor> is listening on.
-  //     If an <ACE_Event_Handler> and <ACE_Select_Reactor_Mask> is
-  //     passed to <notify>, the appropriate <handle_*> method is
-  //     dispatched in the context of the <ACE_Select_Reactor> thread.
-public:
-  ACE_Select_Reactor_Notify (void);
-  ~ACE_Select_Reactor_Notify (void);
-  // Default dtor.
-
-  // = Initialization and termination methods.
-  virtual int open (ACE_Reactor_Impl *,
-                    ACE_Timer_Queue * = 0,
-                    int disable_notify_pipe = 0);
-  // Initialize.
-
-  virtual int close (void);
-  // Destroy.
-
-  virtual ssize_t notify (ACE_Event_Handler * = 0,
-                          ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK,
-                          ACE_Time_Value * = 0);
-  // Called by a thread when it wants to unblock the
-  // <ACE_Select_Reactor>.  This wakeups the <ACE_Select_Reactor> if
-  // currently blocked in select()/poll().  Pass over both the
-  // <Event_Handler> *and* the <mask> to allow the caller to dictate
-  // which <Event_Handler> method the <ACE_Select_Reactor> will
-  // invoke.  The <ACE_Time_Value> indicates how long to blocking
-  // trying to notify the <ACE_Select_Reactor>.  If <timeout> == 0,
-  // the caller will block until action is possible, else will wait
-  // until the relative time specified in *<timeout> elapses).
-
-  virtual int dispatch_notifications (int &number_of_active_handles,
-                                      const ACE_Handle_Set &rd_mask);
-  // Handles pending threads (if any) that are waiting to unblock the
-  // <ACE_Select_Reactor>.
-
-  virtual int handle_input (ACE_HANDLE handle);
-  // Called back by the <ACE_Select_Reactor> when a thread wants to
-  // unblock us.
-
-  virtual void max_notify_iterations (int);
-  // Set the maximum number of times that the
-  // <ACE_Select_Reactor_Notify::handle_input> method will iterate and
-  // dispatch the <ACE_Event_Handlers> that are passed in via the
-  // notify pipe before breaking out of its <recv> loop.  By default,
-  // this is set to -1, which means "iterate until the pipe is empty."
-  // Setting this to a value like "1 or 2" will increase "fairness"
-  // (and thus prevent starvation) at the expense of slightly higher
-  // dispatching overhead.
-
-  virtual int max_notify_iterations (void);
-  // Get the maximum number of times that the
-  // <ACE_Select_Reactor_Notify::handle_input> method will iterate and
-  // dispatch the <ACE_Event_Handlers> that are passed in via the
-  // notify pipe before breaking out of its <recv> loop.
-
-  virtual void dump (void) const;
-  // Dump the state of an object.
-
-  ACE_ALLOC_HOOK_DECLARE;
-  // Declare the dynamic allocation hooks.
-
-private:
-  ACE_Select_Reactor *select_reactor_;
-  // Keep a back pointer to the <ACE_Select_Reactor>.  If this value
-  // if NULL then the <ACE_Select_Reactor> has been initialized with
-  // <disable_notify_pipe>.
-
-  ACE_Pipe notification_pipe_;
-  // Contains the <ACE_HANDLE> the <ACE_Select_Reactor> is listening
-  // on, as well as the <ACE_HANDLE> that threads wanting the
-  // attention of the <ACE_Select_Reactor> will write to.
-
-  int max_notify_iterations_;
-  // Keeps track of the maximum number of times that the
-  // <ACE_Select_Reactor_Notify::handle_input> method will iterate and
-  // dispatch the <ACE_Event_Handlers> that are passed in via the
-  // notify pipe before breaking out of its <recv> loop.  By default,
-  // this is set to -1, which means "iterate until the pipe is empty."
-};
-
-class ACE_Export ACE_Select_Reactor_Handler_Repository
-{
-  // = TITLE
-  //     Used to map <ACE_HANDLE>s onto the appropriate
-  //     <ACE_Event_Handler> *.
-  //
-  // = DESCRIPTION
-  //     This class is necessary to shield differences between UNIX
-  //     and Win32.  In UNIX, <ACE_HANDLE> is an int, whereas in Win32
-  //     it's a void *.  This class hides all these details from the
-  //     bulk of the <ACE_Select_Reactor> code.  All of these methods
-  //     are called with the main <Select_Reactor> token lock held.
-public:
-  friend class ACE_Select_Reactor_Handler_Repository_Iterator;
-
-  // = Initialization and termination methods.
-  ACE_Select_Reactor_Handler_Repository (ACE_Select_Reactor &);
-  // Default "do-nothing" constructor.
-
-  ~ACE_Select_Reactor_Handler_Repository (void);
-  // dtor.
-
-  int open (size_t size);
-  // Initialize a repository of the appropriate <size>.
-
-  int close (void);
-  // Close down the repository.
-
-  // = Search structure operations.
-
-  ACE_Event_Handler *find (ACE_HANDLE handle, size_t *index_p = 0);
-  // Return the <ACE_Event_Handler *> associated with <ACE_HANDLE>.
-  // If <index_p> is non-0, then return the index location of the
-  // <handle>, if found.
-
-  int bind (ACE_HANDLE,
-            ACE_Event_Handler *,
-            ACE_Reactor_Mask);
-  // Bind the <ACE_Event_Handler *> to the <ACE_HANDLE> with the
-  // appropriate <ACE_Reactor_Mask> settings.
-
-  int unbind (ACE_HANDLE,
-              ACE_Reactor_Mask mask);
-  // Remove the binding of <ACE_HANDLE> in accordance with the <mask>.
-
-  int unbind_all (void);
-  // Remove all the <ACE_HANDLE, ACE_Event_Handler> tuples.
-
-  // = Sanity checking.
-
-  // Check the <handle> to make sure it's a valid ACE_HANDLE that
-  // within the range of legal handles (i.e., >= 0 && < max_size_).
-  int invalid_handle (ACE_HANDLE handle);
-
-  // Check the <handle> to make sure it's a valid ACE_HANDLE that
-  // within the range of currently registered handles (i.e., >= 0 && <
-  // max_handlep1_).
-  int handle_in_range (ACE_HANDLE handle);
-
-  // = Accessors.
-  size_t size (void);
-  // Returns the current table size.
-
-  size_t max_handlep1 (void);
-  // Maximum ACE_HANDLE value, plus 1.
-
-  void dump (void) const;
-  // Dump the state of an object.
-
-  ACE_ALLOC_HOOK_DECLARE;
-  // Declare the dynamic allocation hooks.
-
-private:
-  ACE_Select_Reactor &select_reactor_;
-  // Reference to our <Select_Reactor>.
-
-  ssize_t max_size_;
-  // Maximum number of handles.
-
-  int max_handlep1_;
-  // The highest currently active handle, plus 1 (ranges between 0 and
-  // <max_size_>.
-
-#if defined (ACE_WIN32)
-  // = The mapping from <HANDLES> to <Event_Handlers>.
-
-  ACE_Event_Tuple *event_handlers_;
-  // The NT version implements this via a dynamically allocated
-  // array of <ACE_Event_Tuple *>.  Since NT implements ACE_HANDLE
-  // as a void * we can't directly index into this array.  Therefore,
-  // we just do a linear search (for now).  Next, we'll modify
-  // things to use hashing or something faster...
-#else
-  ACE_Event_Handler **event_handlers_;
-  // The UNIX version implements this via a dynamically allocated
-  // array of <ACE_Event_Handler *> that is indexed directly using
-  // the ACE_HANDLE value.
-#endif /* ACE_WIN32 */
-};
-
-class ACE_Export ACE_Select_Reactor_Handler_Repository_Iterator
-{
-  // = TITLE
-  //     Iterate through the <ACE_Select_Reactor_Handler_Repository>.
-public:
-  // = Initialization method.
-  ACE_Select_Reactor_Handler_Repository_Iterator (const ACE_Select_Reactor_Handler_Repository *s);
-
-  ~ACE_Select_Reactor_Handler_Repository_Iterator (void);
-  // dtor.
-
-  // = Iteration methods.
-
-  int next (ACE_Event_Handler *&next_item);
-  // Pass back the <next_item> that hasn't been seen in the Set.
-  // Returns 0 when all items have been seen, else 1.
-
-  int done (void) const;
-  // Returns 1 when all items have been seen, else 0.
-
-  int advance (void);
-  // Move forward by one element in the set.  Returns 0 when all the
-  // items in the set have been seen, else 1.
-
-  void dump (void) const;
-  // Dump the state of an object.
-
-  ACE_ALLOC_HOOK_DECLARE;
-  // Declare the dynamic allocation hooks.
-
-private:
-  const ACE_Select_Reactor_Handler_Repository *rep_;
-  // Reference to the Handler_Repository we are iterating over.
-
-  ssize_t current_;
-  // Pointer to the current iteration level.
-};
-
-class ACE_Export ACE_Select_Reactor : public ACE_Reactor_Impl
-{
-  // = TITLE
-  //     An object oriented event demultiplexor and event handler
-  //     dispatcher.
-  //
-  // = DESCRIPTION
-  //     The ACE_Select_Reactor is an object-oriented event
-  //     demultiplexor and event handler dispatcher.  The sources of
-  //     events that the ACE_Select_Reactor waits for and dispatches
-  //     includes I/O events, signals, and timer events.  All public
-  //     methods acquire the main <Select_Reactor> token lock and call
-  //     down to private or protected methods, which assume that the
-  //     lock is held and so therefore don't (re)acquire the lock.
-public:
-  enum
-  {
-    DEFAULT_SIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE
-    // Default size of the Select_Reactor's handle table.
-  };
-
-  // = Initialization and termination methods.
-
-  ACE_Select_Reactor (ACE_Sig_Handler * = 0,
-                      ACE_Timer_Queue * = 0,
-                      int disable_notify_pipe = 0,
-                      ACE_Reactor_Notify *notify = 0);
-  // Initialize <ACE_Select_Reactor> with the default size.
-
-  ACE_Select_Reactor (size_t size,
-                      int restart = 0,
-                      ACE_Sig_Handler * = 0,
-                      ACE_Timer_Queue * = 0,
-                      int disable_notify_pipe = 0,
-                      ACE_Reactor_Notify *notify = 0);
-  // Initialize <ACE_Select_Reactor> with size <size>.
-
-  virtual int open (size_t size = DEFAULT_SIZE,
-                    int restart = 0,
-                    ACE_Sig_Handler * = 0,
-                    ACE_Timer_Queue * = 0,
-                    int disable_notify_pipe = 0,
-                    ACE_Reactor_Notify * = 0);
-  // Initialize <ACE_Select_Reactor> with size <size>.
-
-  virtual int current_info (ACE_HANDLE, size_t & /* size */);
-  // Returns -1 (not used in this implementation);
-
-  virtual int set_sig_handler (ACE_Sig_Handler *signal_handler);
-  // Use a user specified signal handler instead.
-
-  virtual int set_timer_queue (ACE_Timer_Queue *timer_queue);
-  // Use a user specified timer queue instead.
-
-  virtual int close (void);
-  // Close down the select_reactor and release all of its resources.
-
-  virtual ~ACE_Select_Reactor (void);
-  // Close down the select_reactor and release all of its resources.
-
-  // = Event loop drivers.
-
-  virtual int handle_events (ACE_Time_Value *max_wait_time = 0);
-  virtual int alertable_handle_events (ACE_Time_Value *max_wait_time = 0);
-  // This event loop driver that blocks for <max_wait_time> before
-  // returning.  It will return earlier if timer events, I/O events,
-  // or signal events occur.  Note that <max_wait_time> can be 0, in
-  // which case this method blocks indefinitely until events occur.
-  //
-  // <max_wait_time> is decremented to reflect how much time this call
-  // took.  For instance, if a time value of 3 seconds is passed to
-  // handle_events and an event occurs after 2 seconds,
-  // <max_wait_time> will equal 1 second.  This can be used if an
-  // application wishes to handle events for some fixed amount of
-  // time.
-  //
-  // Returns the total number of <ACE_Event_Handler>s that were
-  // dispatched, 0 if the <max_wait_time> elapsed without dispatching
-  // any handlers, or -1 if something goes wrong.
-  //
-  // Current <alertable_handle_events> is identical to
-  // <handle_events>.
-
-  virtual int handle_events (ACE_Time_Value &max_wait_time);
-  virtual int alertable_handle_events (ACE_Time_Value &max_wait_time);
-  // This method is just like the one above, except the
-  // <max_wait_time> value is a reference and can therefore never be
-  // NULL.
-  //
-  // Current <alertable_handle_events> is identical to
-  // <handle_events>.
-
-  // = Register and remove <ACE_Event_Handler>s.
-  virtual int register_handler (ACE_Event_Handler *eh,
-                                ACE_Reactor_Mask mask);
-  // Register a <eh> with a particular <mask>.  Note that the
-  // <Select_Reactor> will call eh->get_handle() to extract the
-  // underlying I/O handle.
-
-  virtual int register_handler (ACE_HANDLE handle,
-                                ACE_Event_Handler *eh,
-                                ACE_Reactor_Mask mask);
-  // Register a <eh> with a particular <mask>.  Note that since the
-  // <handle> is given the Select_Reactor will *not* call
-  // eh->get_handle() to extract the underlying I/O handle.
-
-#if defined (ACE_WIN32)
-
-  // Originally this interface was available for all platforms, but
-  // because ACE_HANDLE is an int on non-Win32 platforms, compilers
-  // are not able to tell the difference between
-  // register_handler(ACE_Event_Handler*,ACE_Reactor_Mask) and
-  // register_handler(ACE_Event_Handler*,ACE_HANDLE). Therefore, we
-  // have restricted this method to Win32 only.
-
-  virtual int register_handler (ACE_Event_Handler *event_handler,
-                                ACE_HANDLE event_handle = ACE_INVALID_HANDLE);
-  // Not implemented.
-
-#endif /* ACE_WIN32 */
-
-  virtual int register_handler (ACE_HANDLE event_handle,
-                                ACE_HANDLE io_handle,
-                                ACE_Event_Handler *event_handler,
-                                ACE_Reactor_Mask mask);
-  // Not implemented.
-
-  virtual int register_handler (const ACE_Handle_Set &handles,
-                                ACE_Event_Handler *eh,
-                                ACE_Reactor_Mask mask);
-  // Register <eh> with all the <handles> in the <Handle_Set>.
-
-  virtual int register_handler (int signum,
-                                ACE_Event_Handler *new_sh,
-                                ACE_Sig_Action *new_disp = 0,
-                                ACE_Event_Handler **old_sh = 0,
-                                ACE_Sig_Action *old_disp = 0);
-  // Register <new_sh> to handle the signal <signum> using the
-  // <new_disp>.  Returns the <old_sh> that was previously registered
-  // (if any), along with the <old_disp> of the signal handler.
-
-  virtual int register_handler (const ACE_Sig_Set &sigset,
-                                ACE_Event_Handler *new_sh,
-                                ACE_Sig_Action *new_disp = 0);
-  // Registers <new_sh> to handle a set of signals <sigset> using the
-  // <new_disp>.
-
-  virtual int remove_handler (ACE_Event_Handler *eh,
-                              ACE_Reactor_Mask mask);
-  // Removes the <mask> binding of <eh> from the Select_Reactor.  If
-  // there are no more bindings for this <eh> then it is removed from
-  // the Select_Reactor.  Note that the Select_Reactor will call
-  // eh->get_handle() to extract the underlying I/O handle.
-
-  virtual int remove_handler (ACE_HANDLE handle,
-                              ACE_Reactor_Mask);
-  // Removes the <mask> bind of <Event_Handler> whose handle is
-  // <handle> from the Select_Reactor.  If there are no more bindings
-  // for this <eh> then it is removed from the Select_Reactor.
-
-  virtual int remove_handler (const ACE_Handle_Set &handle_set,
-                              ACE_Reactor_Mask);
-  // Removes all the <mask> bindings for handles in the <handle_set>
-  // bind of <Event_Handler>.  If there are no more bindings for any
-  // of these handlers then they are removed from the Select_Reactor.
-
-  virtual int remove_handler (int signum,
-                              ACE_Sig_Action *new_disp,
-                              ACE_Sig_Action *old_disp = 0,
-                              int sigkey = -1);
-  // Remove the ACE_Event_Handler currently associated with <signum>.
-  // <sigkey> is ignored in this implementation since there is only
-  // one instance of a signal handler.  Install the new disposition
-  // (if given) and return the previous disposition (if desired by the
-  // caller).  Returns 0 on success and -1 if <signum> is invalid.
-
-  virtual int remove_handler (const ACE_Sig_Set &sigset);
-  // Calls <remove_handler> for every signal in <sigset>.
-
-  // = Suspend and resume Handlers.
-
-  virtual int suspend_handler (ACE_Event_Handler *eh);
-  // Temporarily suspend the <Event_Handler> associated with <eh>.
-
-  virtual int suspend_handler (ACE_HANDLE handle);
-  // Temporarily suspend the <Event_Handler> associated with <handle>.
-
-  virtual int suspend_handler (const ACE_Handle_Set &handles);
-  // Suspend all <handles> in handle set temporarily.
-
-  virtual int suspend_handlers (void);
-  // Suspend all the <Event_Handlers> in the Select_Reactor.
-
-  virtual int resume_handler (ACE_Event_Handler *eh);
-  // Resume a temporarily suspend <Event_Handler> associated with
-  // <eh>.
-
-  virtual int resume_handler (ACE_HANDLE handle);
-  // Resume a temporarily suspended <Event_Handler> associated with
-  // <handle>.
-
-  virtual int resume_handler (const ACE_Handle_Set &handles);
-  // Resume all <handles> in handle set.
-
-  virtual int resume_handlers (void);
-  // Resume all the <Event_Handlers> in the Select_Reactor.
-
-  virtual int uses_event_associations (void);
-  // Return 1 if we any event associations were made by the reactor
-  // for the handles that it waits on, 0 otherwise. Since the
-  // Select_Reactor does not do any event associations, this function
-  // always return 0.
-
-  // = Timer management.
-  virtual long schedule_timer (ACE_Event_Handler *,
-                               const void *arg,
-                               const ACE_Time_Value &delta_time,
-                               const ACE_Time_Value &interval = ACE_Time_Value::zero);
-  // Schedule an <event_handler> that will expire after <delta_time>
-  // amount of time.  If it expires then <arg> is passed in as the
-  // value to the <event_handler>'s <handle_timeout> callback method.
-  // If <interval> is != to <ACE_Time_Value::zero> then it is used to
-  // reschedule the <event_handler> automatically.  This method
-  // returns a <timer_id> that uniquely identifies the <event_handler>
-  // in an internal list.  This <timer_id> can be used to cancel an
-  // <event_handler> before it expires.  The cancellation ensures that
-  // <timer_ids> are unique up to values of greater than 2 billion
-  // timers.  As long as timers don't stay around longer than this
-  // there should be no problems with accidentally deleting the wrong
-  // timer.  Returns -1 on failure (which is guaranteed never to be a
-  // valid <timer_id>.
-
-  virtual int cancel_timer (ACE_Event_Handler *event_handler,
-                            int dont_call_handle_close = 1);
-  // Cancel all <event_handlers> that match the address of
-  // <event_handler>.  If <dont_call_handle_close> is 0 then the
-  // <handle_close> method of <event_handler> will be invoked.
-  // Returns number of handler's cancelled.
-
-  virtual int cancel_timer (long timer_id,
-                            const void **arg = 0,
-                            int dont_call_handle_close = 1);
-  // Cancel the single <ACE_Event_Handler> that matches the <timer_id>
-  // value (which was returned from the <schedule> method).  If arg is
-  // non-NULL then it will be set to point to the ``magic cookie''
-  // argument passed in when the <Event_Handler> was registered.  This
-  // makes it possible to free up the memory and avoid memory leaks.
-  // If <dont_call_handle_close> is 0 then the <handle_close> method
-  // of <event_handler> will be invoked.  Returns 1 if cancellation
-  // succeeded and 0 if the <timer_id> wasn't found.
-
-  // = High-level Event_Handler scheduling operations
-
-  virtual int schedule_wakeup (ACE_Event_Handler *eh,
-                               ACE_Reactor_Mask mask);
-  // ADD the dispatch MASK "bit" bound with the <eh> and the <mask>.
-
-  virtual int schedule_wakeup (ACE_HANDLE handle,
-                               ACE_Reactor_Mask mask);
-  // ADD the dispatch MASK "bit" bound with the <handle> and the <mask>.
-
-  virtual int cancel_wakeup (ACE_Event_Handler *eh,
-                             ACE_Reactor_Mask mask);
-  // CLR the dispatch MASK "bit" bound with the <eh> and the <mask>.
-
-  virtual int cancel_wakeup (ACE_HANDLE handle,
-                             ACE_Reactor_Mask mask);
-  // CLR the dispatch MASK "bit" bound with the <handle> and the <mask>.
-
-  // = Notification methods.
-  virtual int notify (ACE_Event_Handler * = 0,
-                      ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK,
-                      ACE_Time_Value * = 0);
-  // Called by a thread when it wants to unblock the Select_Reactor.
-  // This wakeups the <ACE_Select_Reactor> if currently blocked in
-  // select()/poll().  Pass over both the <Event_Handler> *and* the
-  // <mask> to allow the caller to dictate which <Event_Handler>
-  // method the <Select_Reactor> will invoke.  The <ACE_Time_Value>
-  // indicates how long to blocking trying to notify the
-  // <Select_Reactor>.  If <timeout> == 0, the caller will block until
-  // action is possible, else will wait until the relative time
-  // specified in *<timeout> elapses).
-
-  virtual void max_notify_iterations (int);
-  // Set the maximum number of times that the
-  // <ACE_Select_Reactor_Notify::handle_input> method will iterate and
-  // dispatch the <ACE_Event_Handlers> that are passed in via the
-  // notify pipe before breaking out of its <recv> loop.  By default,
-  // this is set to -1, which means "iterate until the pipe is empty."
-  // Setting this to a value like "1 or 2" will increase "fairness"
-  // (and thus prevent starvation) at the expense of slightly higher
-  // dispatching overhead.
-
-  virtual int max_notify_iterations (void);
-  // Get the maximum number of times that the
-  // <ACE_Select_Reactor_Notify::handle_input> method will iterate and
-  // dispatch the <ACE_Event_Handlers> that are passed in via the
-  // notify pipe before breaking out of its <recv> loop.
-
-  virtual void requeue_position (int);
-  // Set position that the main ACE_Select_Reactor thread is requeued in the
-  // list of waiters during a notify() callback.
-
-  virtual int requeue_position (void);
-  // Get position that the main ACE_Select_Reactor thread is requeued in the
-  // list of waiters during a notify() callback.
-
-  // = Low-level wait_set mask manipulation methods.
-  virtual int mask_ops (ACE_Event_Handler *eh,
-                        ACE_Reactor_Mask mask,
-                        int ops);
-  // GET/SET/ADD/CLR the dispatch mask "bit" bound with the <eh> and
-  // <mask>.
-
-  virtual int mask_ops (ACE_HANDLE handle,
-                        ACE_Reactor_Mask mask,
-                        int ops);
-  // GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle>
-  // and <mask>.
-
-  // = Low-level ready_set mask manipulation methods.
-  virtual int ready_ops (ACE_Event_Handler *eh,
-                         ACE_Reactor_Mask mask,
-                         int ops);
-  // GET/SET/ADD/CLR the ready "bit" bound with the <eh> and <mask>.
-
-  virtual int ready_ops (ACE_HANDLE handle,
-                         ACE_Reactor_Mask,
-                         int ops);
-  // GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
-
-  virtual void wakeup_all_threads (void);
-  // Wake up all threads in waiting in the event loop
-
-  // = Only the owner thread that can perform a <handle_events>.
-
-  virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0);
-  // Set the new owner of the thread and return the old owner.
-
-  virtual int owner (ACE_thread_t *);
-  // Return the current owner of the thread.
-
-  // = Miscellaneous Handler operations.
-  virtual int handler (ACE_HANDLE handle,
-                       ACE_Reactor_Mask mask,
-                       ACE_Event_Handler **eh = 0);
-  // Check to see if <handle> is associated with a valid Event_Handler
-  // bound to <mask>.  Return the <eh> associated with this <handler>
-  // if <eh> != 0.
-
-  virtual int handler (int signum,
-                       ACE_Event_Handler ** = 0);
-  // Check to see if <signum> is associated with a valid Event_Handler
-  // bound to a signal.  Return the <eh> associated with this
-  // <handler> if <eh> != 0.
-
-  virtual int initialized (void);
-  // Returns true if we've been successfully initialized, else false.
-
-  virtual size_t size (void);
-  // Returns the current size of the Reactor's internal descriptor
-  // table.
-
-  virtual ACE_Lock &lock (void);
-  // Returns a reference to the <ACE_Select_Reactor_Token> that is
-  // used to serialize the internal Select_Reactor's processing logic.
-  // This can be useful for situations where you need to avoid
-  // deadlock efficiently when <ACE_Event_Handlers> are used in
-  // multiple threads.
-
-  virtual void dump (void) const;
-  // Dump the state of an object.
-
-  ACE_ALLOC_HOOK_DECLARE;
-  // Declare the dynamic allocation hooks.
-
-protected:
-  // = Internal methods that do the actual work.
-
-  // All of these methods assume that the <Select_Reactor>'s token
-  // lock is held by the public methods that call down to them.
-
-  virtual int register_handler_i (ACE_HANDLE handle,
-                                  ACE_Event_Handler *eh,
-                                  ACE_Reactor_Mask mask);
-  // Do the work of actually binding the <handle> and <eh> with the
-  // <mask>.
-
-  virtual int register_handler_i (const ACE_Handle_Set &handles,
-                                  ACE_Event_Handler *handler,
-                                  ACE_Reactor_Mask mask);
-  // Register a set of <handles>.
-
-  virtual int remove_handler_i (ACE_HANDLE handle,
-                                ACE_Reactor_Mask);
-  // Do the work of actually unbinding the <handle> and <eh> with the
-  // <mask>.
-
-  virtual int remove_handler_i (const ACE_Handle_Set &handles,
-                                ACE_Reactor_Mask);
-  // Remove a set of <handles>.
-
-  virtual int suspend_i (ACE_HANDLE handle);
-  // Suspend the <Event_Handler> associated with <handle>
-
-  virtual int resume_i (ACE_HANDLE handle);
-  // Resume the <Event_Handler> associated with <handle>
-
-  virtual int handler_i (ACE_HANDLE handle,
-                         ACE_Reactor_Mask,
-                         ACE_Event_Handler ** = 0);
-  // Implement the public <handler> method.
-
-  virtual int handler_i (int signum, ACE_Event_Handler ** = 0);
-  // Implement the public <handler> method.
-
-  virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set);
-  // Check if there are any HANDLEs enabled in the <ready_set_>, and
-  // if so, update the <handle_set> and return the number ready.  If
-  // there aren't any HANDLEs enabled return 0.
-
-  virtual int handle_error (void);
-  // Take corrective action when errors occur.
-
-  virtual int check_handles (void);
-  // Make sure the handles are all valid.
-
-  virtual int bit_ops (ACE_HANDLE handle,
-                       ACE_Reactor_Mask mask,
-                       ACE_Select_Reactor_Handle_Set &wait_Set,
-                       int ops);
-  // Allow manipulation of the <wait_set_> mask and <ready_set_> mask.
-
-  virtual int wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &,
-                                        ACE_Time_Value *);
-  // Wait for events to occur.
-
-  // = Dispatching methods.
-
-  virtual int dispatch (int nfound,
-                        ACE_Select_Reactor_Handle_Set &);
-  // Template Method that dispatches <ACE_Event_Handler>s for time
-  // events, I/O events, and signal events.  Returns the total number
-  // of <ACE_Event_Handler>s that were dispatched or -1 if something
-  // goes wrong.
-
-  virtual int dispatch_timer_handlers (void);
-  // Dispatch any expired timer handlers.  Returns -1 if the state of
-  // the <wait_set_> has changed, else returns number of timer
-  // handlers dispatched.
-
-  virtual int dispatch_notification_handlers (int &number_of_active_handles,
-                                              ACE_Select_Reactor_Handle_Set &dispatch_set);
-  // Dispatch any notification handlers.  Returns -1 if the state of
-  // the <wait_set_> has changed, else returns number of handlers
-  // notified.
-
-  virtual int dispatch_io_handlers (int &number_of_active_handles,
-                                    ACE_Select_Reactor_Handle_Set &dispatch_set);
-  // Dispatch all the input/output/except handlers that are enabled in
-  // the <dispatch_set>.  Returns -1 if the state of the <wait_set_>
-  // has changed, else returns number of handlers dispatched.
-
-  virtual int 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);
-  // Factors the dispatching of an io handle set (each WRITE, EXCEPT
-  // or READ set of handles).
-  // It updates the number of handles already dispatched and
-  // invokes this->notify_handle for all the handles in <dispatch_set>
-  // using the <mask>, <ready_set> and <callback> parameters.
-  // Must return -1 if this->state_changed otherwise it must return 0.
-
-  virtual void notify_handle (ACE_HANDLE handle,
-                              ACE_Reactor_Mask mask,
-                              ACE_Handle_Set &,
-                              ACE_Event_Handler *eh,
-                              ACE_EH_PTMF callback);
-  // Notify the appropriate <callback> in the context of the <eh>
-  // associated with <handle> that a particular event has occurred.
-
-  ACE_Select_Reactor_Handler_Repository handler_rep_;
-  // Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s.
-
-  ACE_Timer_Queue *timer_queue_;
-  // Defined as a pointer to allow overriding by derived classes...
-
-  int delete_timer_queue_;
-  // Keeps track of whether we should delete the timer queue (if we
-  // didn't create it, then we don't delete it).
-
-  ACE_Sig_Handler *signal_handler_;
-  // Handle signals without requiring global/static variables.
-
-  int delete_signal_handler_;
-  // Keeps track of whether we should delete the signal handler (if we
-  // didn't create it, then we don't delete it).
-
-  ACE_Reactor_Notify *notify_handler_;
-  // Callback object that unblocks the <ACE_Select_Reactor> if it's
-  // sleeping.
-
-  int delete_notify_handler_;
-  // Keeps track of whether we need to delete the notify handler (if
-  // we didn't create it, then we don't delete it).
-
-  ACE_Select_Reactor_Handle_Set wait_set_;
-  // Tracks handles that are waited for by select().
-
-  ACE_Select_Reactor_Handle_Set suspend_set_;
-  // Tracks handles that are currently suspended.
-
-  ACE_Select_Reactor_Handle_Set ready_set_;
-  // Track HANDLES we are interested in for various events that must
-  // be dispatched *without* going through select().
-
-  int restart_;
-  // Restart automatically when interrupted
-
-  int requeue_position_;
-  // Position that the main ACE_Select_Reactor thread is requeued in
-  // the list of waiters during a notify() callback.  If this value ==
-  // -1 we are requeued at the end of the list.  Else if it's 0 then
-  // we are requeued at the front of the list.  Else if it's > 1 then
-  // that indicates the number of waiters to skip over.
-
-  int initialized_;
-  // True if we've been initialized yet...
-
-  ACE_thread_t owner_;
-  // The original thread that created this Select_Reactor.
-
-  int state_changed_;
-  // True if state has changed during dispatching of
-  // <ACE_Event_Handlers>, else false.  This is used to determine
-  // whether we need to make another trip through the
-  // <Select_Reactor>'s <wait_for_multiple_events> loop.
-
-  ACE_Select_Reactor_Token token_;
-  // Synchronization token for the MT_SAFE ACE_Select_Reactor.
-
-  ACE_Lock_Adapter<ACE_Select_Reactor_Token> lock_adapter_;
-  // Adapter used to return internal lock to outside world.
-
-  void renew (void);
-  // Enqueue ourselves into the list of waiting threads at the
-  // appropriate point specified by <requeue_position_>.
-
-  int release_token (void);
-  // Release the token lock when a Win32 structured exception occurs.
-
-  int handle_events_i (ACE_Time_Value *max_wait_time = 0);
-  // Stops the VC++ compiler from bitching about exceptions and destructors
-
-
-  int supress_notify_renew (void);
-  void supress_notify_renew (int sr);
-  // Controls/access whether the notify handler should renew the
-  // Select_Reactor's token or not.
-
-  friend class ACE_Select_Reactor_Notify;
-  friend class ACE_Select_Reactor_Handler_Repository;
-
-private:
-  int supress_renew_;
-  // Determine whether we should renew Select_Reactor's token after handling
-  // the notification message.
+typedef ACE_Select_Reactor_Token_T<ACE_Noop_Token> ACE_Select_Reactor_Token;
+#endif /* ACE_MT_SAFE && ACE_MT_SAFE != 0 */
 
-  ACE_Select_Reactor (const ACE_Select_Reactor &);
-  ACE_Select_Reactor &operator = (const ACE_Select_Reactor &);
-  // Deny access since member-wise won't work...
-};
+typedef ACE_Select_Reactor_T<ACE_Select_Reactor_Token> ACE_Select_Reactor;
 
 #if defined (__ACE_INLINE__)
 #include "ace/Select_Reactor.i"