1 files changed, 23 insertions, 23 deletions

diff --git a/ACE/ace/Lock.h b/ACE/ace/Lock.h
index f1318800153..2216a6f5581 100644
--- a/ACE/ace/Lock.h
+++ b/ACE/ace/Lock.h
@@ -42,45 +42,45 @@ class ACE_Export ACE_Lock
 {
 public:
   /// CE needs a default constructor here.
-  ACE_Lock (void);
+  ACE_Lock ();
 
   /// Noop virtual destructor
-  virtual ~ACE_Lock (void);
+  virtual ~ACE_Lock ();
 
   /**
    * Explicitly destroy the lock.  Note that only one thread should
    * call this method since it doesn't protect against race
    * conditions.
    */
-  virtual int remove (void) = 0;
+  virtual int remove () = 0;
 
   /// Block the thread until the lock is acquired.  Returns -1 on
   /// failure.
-  virtual int acquire (void) = 0;
+  virtual int acquire () = 0;
 
   /**
    * Conditionally acquire the 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.
    */
-  virtual int tryacquire (void) = 0;
+  virtual int tryacquire () = 0;
 
   /// Release the lock.  Returns -1 on failure.
-  virtual int release (void) = 0;
+  virtual int release () = 0;
 
   /**
    * Block until the thread acquires a read lock.  If the locking
    * mechanism doesn't support read locks then this just calls
    * acquire().  Returns -1 on failure.
    */
-  virtual int acquire_read (void) = 0;
+  virtual int acquire_read () = 0;
 
   /**
    * Block until the thread acquires a write lock.  If the locking
    * mechanism doesn't support read locks then this just calls
    * acquire().  Returns -1 on failure.
    */
-  virtual int acquire_write (void) = 0;
+  virtual int acquire_write () = 0;
 
   /**
    * Conditionally acquire a read lock.  If the locking mechanism
@@ -88,7 +88,7 @@ public:
    * Returns -1 on failure.  If we "failed" because someone else
    * already had the lock, @c errno is set to @c EBUSY.
    */
-  virtual int tryacquire_read (void) = 0;
+  virtual int tryacquire_read () = 0;
 
   /**
    * Conditionally acquire a write lock.  If the locking mechanism
@@ -96,14 +96,14 @@ public:
    * Returns -1 on failure.  If we "failed" because someone else
    * already had the lock, @c errno is set to @c EBUSY.
    */
-  virtual int tryacquire_write (void) = 0;
+  virtual int tryacquire_write () = 0;
 
   /**
    * Conditionally try to upgrade a lock held for read to a write lock.
    * If the locking mechanism doesn't support read locks then this just
    * calls acquire(). Returns 0 on success, -1 on failure.
    */
-  virtual int tryacquire_write_upgrade (void) = 0;
+  virtual int tryacquire_write_upgrade () = 0;
 };
 
 /**
@@ -123,20 +123,20 @@ class ACE_Export ACE_Adaptive_Lock : public ACE_Lock
 public:
   /// You must also override the destructor function to match with how
   /// you construct the underneath @c lock_.
-  virtual ~ACE_Adaptive_Lock (void);
+  virtual ~ACE_Adaptive_Lock ();
 
   // = Lock/unlock operations.
 
-  virtual int remove (void);
-  virtual int acquire (void);
-  virtual int tryacquire (void);
-  virtual int release (void);
-  virtual int acquire_read (void);
-  virtual int acquire_write (void);
-  virtual int tryacquire_read (void);
-  virtual int tryacquire_write (void);
-  virtual int tryacquire_write_upgrade (void);
-  void dump (void) const;
+  virtual int remove ();
+  virtual int acquire ();
+  virtual int tryacquire ();
+  virtual int release ();
+  virtual int acquire_read ();
+  virtual int acquire_write ();
+  virtual int tryacquire_read ();
+  virtual int tryacquire_write ();
+  virtual int tryacquire_write_upgrade ();
+  void dump () const;
 
 protected:
   /**
@@ -144,7 +144,7 @@ protected:
    * The default constructor simply set the @c lock_ to 0 (null).  You
    * must overwrite this method for this class to work.
    */
-  ACE_Adaptive_Lock (void);
+  ACE_Adaptive_Lock ();
 
   ACE_Lock *lock_;
 };