Removed redundant void

1 files changed, 12 insertions, 12 deletions

diff --git a/ACE/ace/RW_Mutex.h b/ACE/ace/RW_Mutex.h
index 46f7458ed39..f01f4dc035f 100644
--- a/ACE/ace/RW_Mutex.h
+++ b/ACE/ace/RW_Mutex.h
@@ -45,31 +45,31 @@ public:
                 void *arg = 0);
 
   /// Implicitly destroy a readers/writer lock
-  ~ACE_RW_Mutex (void);
+  ~ACE_RW_Mutex ();
 
   /**
    * Explicitly destroy a readers/writer lock.  Note that only one
    * thread should call this method since it doesn't protect against
    * race conditions.
    */
-  int remove (void);
+  int remove ();
 
   /// Acquire a read lock, but block if a writer hold the lock.
-  int acquire_read (void);
+  int acquire_read ();
 
   /// Acquire a write lock, but block if any readers or a
   /// writer hold the lock.
-  int acquire_write (void);
+  int acquire_write ();
 
   /**
    * Conditionally acquire a read lock (i.e., won't block).  Returns
    * -1 on failure.  If we "failed" because someone else already had
    * the lock, @c errno is set to @c EBUSY.
    */
-  int tryacquire_read (void);
+  int tryacquire_read ();
 
   /// Conditionally acquire a write lock (i.e., won't block).
-  int tryacquire_write (void);
+  int tryacquire_write ();
 
   /**
    * Conditionally upgrade a read lock to a write lock.  This only
@@ -79,14 +79,14 @@ public:
    * already possess this lock as a read lock (but this condition is
    * not checked by the current implementation).
    */
-  int tryacquire_write_upgrade (void);
+  int tryacquire_write_upgrade ();
 
   /**
    * Note, for interface uniformity with other synchronization
    * wrappers we include the <acquire> method.  This is implemented as
    * a write-lock to safe...
    */
-  int acquire (void);
+  int acquire ();
 
   /**
    * Note, for interface uniformity with other synchronization
@@ -95,16 +95,16 @@ public:
    * "failed" because someone else already had the lock, @c errno is
    * set to @c EBUSY.
    */
-  int tryacquire (void);
+  int tryacquire ();
 
   /// Unlock a readers/writer lock.
-  int release (void);
+  int release ();
 
   /// Return the underlying lock.
-  const ACE_rwlock_t &lock (void) const;
+  const ACE_rwlock_t &lock () const;
 
   /// Dump the state of an object.
-  void dump (void) const;
+  void dump () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;