From 6f91193f0b537d437645ae9e10823a519f547888 Mon Sep 17 00:00:00 2001 From: Johnny Willemsen Date: Wed, 9 Dec 2020 12:39:57 +0100 Subject: Removed redundant void --- ACE/ace/Thread_Manager.h | 74 ++++++++++++++++++++++++------------------------ 1 file changed, 37 insertions(+), 37 deletions(-) (limited to 'ACE/ace/Thread_Manager.h') 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; friend class ACE_Double_Linked_List_Iterator; 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; friend class ACE_Double_Linked_List_Iterator; 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. -- cgit v1.2.1