1 files changed, 37 insertions, 37 deletions

diff --git a/ACE/ace/Thread_Manager.h b/ACE/ace/Thread_Manager.h
index c169d0e152f..228b27711eb 100644
--- a/ACE/ace/Thread_Manager.h
+++ b/ACE/ace/Thread_Manager.h
@@ -90,19 +90,19 @@ class ACE_Export ACE_At_Thread_Exit
   friend class ACE_Thread_Manager;
 public:
   /// Default constructor
-  ACE_At_Thread_Exit (void);
+  ACE_At_Thread_Exit ();
 
   /// The destructor
-  virtual ~ACE_At_Thread_Exit (void);
+  virtual ~ACE_At_Thread_Exit ();
 
   /// At_Thread_Exit has the ownership?
-  bool is_owner (void) const;
+  bool is_owner () const;
 
   /// Set the ownership of the At_Thread_Exit.
   bool is_owner (bool owner);
 
   /// This At_Thread_Exit was applied?
-  bool was_applied (void) const;
+  bool was_applied () const;
 
   /// Set applied state of At_Thread_Exit.
   bool was_applied (bool applied);
@@ -112,10 +112,10 @@ protected:
   ACE_At_Thread_Exit *next_;
 
   /// Do the apply if necessary
-  void do_apply (void);
+  void do_apply ();
 
   /// The apply method.
-  virtual void apply (void) = 0;
+  virtual void apply () = 0;
 
   /// The Thread_Descriptor where this at is registered.
   ACE_Thread_Descriptor* td_;
@@ -135,7 +135,7 @@ public:
                             ACE_CLEANUP_FUNC func,
                             void *param = 0);
 
-  virtual ~ACE_At_Thread_Exit_Func (void);
+  virtual ~ACE_At_Thread_Exit_Func ();
 
   ACE_ALLOC_HOOK_DECLARE;
 
@@ -150,7 +150,7 @@ protected:
    void *param_;
 
    /// The apply method
-   void apply (void);
+   void apply ();
 };
 
 /**
@@ -173,8 +173,8 @@ class ACE_Export ACE_Thread_Descriptor_Base : public ACE_OS_Thread_Descriptor
   friend class ACE_Double_Linked_List_Iterator_Base<ACE_Thread_Descriptor>;
   friend class ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor>;
 public:
-  ACE_Thread_Descriptor_Base (void);
-  virtual ~ACE_Thread_Descriptor_Base (void);
+  ACE_Thread_Descriptor_Base ();
+  virtual ~ACE_Thread_Descriptor_Base ();
 
   // = We need the following operators to make Borland happy.
 
@@ -185,20 +185,20 @@ public:
   bool operator!= (const ACE_Thread_Descriptor_Base &rhs) const;
 
   /// Group ID.
-  int grp_id (void) const;
+  int grp_id () const;
 
   /// Current state of the thread.
-  ACE_UINT32 state (void) const;
+  ACE_UINT32 state () const;
 
   /// Return the pointer to an ACE_Task_Base or NULL if there's no
   /// ACE_Task_Base associated with this thread.;
-  ACE_Task_Base *task (void) const;
+  ACE_Task_Base *task () const;
 
   ACE_ALLOC_HOOK_DECLARE;
 
 protected:
   /// Reset this base thread descriptor.
-  void reset (void);
+  void reset ();
 
   /// Unique thread ID.
   ACE_thread_t thr_id_;
@@ -235,17 +235,17 @@ class ACE_Export ACE_Thread_Descriptor : public ACE_Thread_Descriptor_Base
   friend class ACE_Double_Linked_List<ACE_Thread_Descriptor>;
   friend class ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor>;
 public:
-  ACE_Thread_Descriptor (void);
+  ACE_Thread_Descriptor ();
 
   // = Accessor methods.
   /// Unique thread id.
-  ACE_thread_t self (void) const;
+  ACE_thread_t self () const;
 
   /// Unique handle to thread (used by Win32 and AIX).
   void self (ACE_hthread_t &);
 
   /// Dump the state of an object.
-  void dump (void) const;
+  void dump () const;
 
   /**
    * This cleanup function must be called only for ACE_TSS_cleanup.
@@ -281,7 +281,7 @@ public:
                void *param);
 
   /// Do nothing destructor to keep some compilers happy
-  ~ACE_Thread_Descriptor (void);
+  ~ACE_Thread_Descriptor ();
 
   /**
    * Do nothing but to acquire the thread descriptor's lock and
@@ -292,23 +292,23 @@ public:
    * thread descriptor before it gets fully built.  This function is
    * only called from ACE_Log_Msg::thr_desc.
    */
-  void acquire_release (void);
-  void acquire (void);
-  void release (void);
+  void acquire_release ();
+  void acquire ();
+  void release ();
 
   /**
    * Set/get the @c next_ pointer.  These are required by the
    * ACE_Free_List.
    */
   void set_next (ACE_Thread_Descriptor *td);
-  ACE_Thread_Descriptor *get_next (void) const;
+  ACE_Thread_Descriptor *get_next () const;
 
 protected:
   /// Run the AT_Thread_Exit hooks.
-  void do_at_exit (void);
+  void do_at_exit ();
 
   /// Terminate realize the cleanup process to thread termination
-  void terminate (void);
+  void terminate ();
 
 private:
   /// Reset this thread descriptor.
@@ -445,18 +445,18 @@ public:
                       size_t lwm = ACE_DEFAULT_THREAD_MANAGER_LWM,
                       size_t inc = ACE_DEFAULT_THREAD_MANAGER_INC,
                       size_t hwm = ACE_DEFAULT_THREAD_MANAGER_HWM);
-  ~ACE_Thread_Manager (void);
+  ~ACE_Thread_Manager ();
 
 #if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS)
   /// Get pointer to a process-wide ACE_Thread_Manager.
-  static ACE_Thread_Manager *instance (void);
+  static ACE_Thread_Manager *instance ();
 
   /// Set pointer to a process-wide ACE_Thread_Manager and return
   /// existing pointer.
   static ACE_Thread_Manager *instance (ACE_Thread_Manager *);
 
   /// Delete the dynamically allocated Singleton
-  static void close_singleton (void);
+  static void close_singleton ();
 #endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */
 
   /// No-op.  Currently unused.
@@ -469,7 +469,7 @@ public:
    * are destroyed and thus, close() does not try to wait; it simply cleans
    * up internal thread records (the thread descriptor list).
    */
-  int close (void);
+  int close ();
 
   /**
    * Create a new thread, which executes @a func with argument @a arg.
@@ -766,14 +766,14 @@ public:
    * Return the unique ID of the calling thread.
    * Same as calling ACE_Thread::self().
    */
-  ACE_thread_t thr_self (void);
+  ACE_thread_t thr_self ();
 
   /**
    * Returns a pointer to the current ACE_Task_Base we're executing
    * in if this thread is indeed running in an ACE_Task_Base, else
    * return 0.
    */
-  ACE_Task_Base *task (void);
+  ACE_Task_Base *task ();
 
   /**
    * @name Suspend and resume methods
@@ -784,7 +784,7 @@ public:
   //@{
 
   /// Suspend all threads
-  int suspend_all (void);
+  int suspend_all ();
 
   /// Suspend a single thread.
   int suspend (ACE_thread_t);
@@ -799,7 +799,7 @@ public:
   int testsuspend (ACE_thread_t t_id);
 
   /// Resume all stopped threads
-  int resume_all (void);
+  int resume_all ();
 
   /// Resume a single thread.
   int resume (ACE_thread_t);
@@ -1037,7 +1037,7 @@ public:
 
   /// Return a count of the current number of threads active in the
   /// Thread_Manager.
-  size_t count_threads (void) const;
+  size_t count_threads () const;
 
   /// Get the state of the thread. Returns false if the thread is not
   /// managed by this thread manager.
@@ -1081,10 +1081,10 @@ public:
   /// Access function to determine whether the Thread_Manager will
   /// wait for its thread to exit or not when being closing down.
   void wait_on_exit (int dowait);
-  int wait_on_exit (void);
+  int wait_on_exit ();
 
   /// Dump the state of an object.
-  void dump (void);
+  void dump ();
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -1096,7 +1096,7 @@ protected:
    * This must be called from a spawn thread.  This function will
    * fetch the info from TSS.
    */
-  ACE_Thread_Descriptor *thread_desc_self (void);
+  ACE_Thread_Descriptor *thread_desc_self ();
 
   /// Return a pointer to the thread's Thread_Descriptor,
   /// 0 if fail.
@@ -1158,7 +1158,7 @@ protected:
                    int close_handler);
 
   /// Remove all threads from the table.
-  void remove_thr_all (void);
+  void remove_thr_all ();
 
   // = The following four methods implement a simple scheme for
   // operating on a collection of threads atomically.