Remove redundant void arg

19 files changed, 192 insertions, 192 deletions

diff --git a/ACE/ace/ARGV.cpp b/ACE/ace/ARGV.cpp
index 18790043ef4..d7af2f8457c 100644
--- a/ACE/ace/ARGV.cpp
+++ b/ACE/ace/ARGV.cpp
@@ -18,7 +18,7 @@ ACE_ALLOC_HOOK_DEFINE_Tt (ACE_ARGV_T)
 
 template <typename CHAR_TYPE>
 void
-ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::dump (void) const
+ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::dump () const
 {
 #if defined (ACE_HAS_DUMP)
   ACE_TRACE ("ACE_ARGV_Queue_Entry_T::dump");
@@ -32,7 +32,7 @@ ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::dump (void) const
 
 template <typename CHAR_TYPE>
 void
-ACE_ARGV_T<CHAR_TYPE>::dump (void) const
+ACE_ARGV_T<CHAR_TYPE>::dump () const
 {
 #if defined (ACE_HAS_DUMP)
   ACE_TRACE ("ACE_ARGV_T::dump");
@@ -61,7 +61,7 @@ ACE_ARGV_T<CHAR_TYPE>::dump (void) const
 
 template <typename CHAR_TYPE>
 int
-ACE_ARGV_T<CHAR_TYPE>::string_to_argv (void)
+ACE_ARGV_T<CHAR_TYPE>::string_to_argv ()
 {
   ACE_TRACE ("ACE_ARGV_T::string_to_argv");
 
@@ -303,7 +303,7 @@ ACE_ARGV_T<CHAR_TYPE>::add (CHAR_TYPE *argv[], bool quote_args)
 // Free up argv_ and buf_
 
 template <typename CHAR_TYPE>
-ACE_ARGV_T<CHAR_TYPE>::~ACE_ARGV_T (void)
+ACE_ARGV_T<CHAR_TYPE>::~ACE_ARGV_T ()
 {
   ACE_TRACE ("ACE_ARGV_T::~ACE_ARGV_T");
 
@@ -331,7 +331,7 @@ ACE_ARGV_T<CHAR_TYPE>::~ACE_ARGV_T (void)
 
 template <typename CHAR_TYPE>
 int
-ACE_ARGV_T<CHAR_TYPE>::create_buf_from_queue (void)
+ACE_ARGV_T<CHAR_TYPE>::create_buf_from_queue ()
 {
   ACE_TRACE ("ACE_ARGV_T::create_buf_from_queue");
 
diff --git a/ACE/ace/ARGV.h b/ACE/ace/ARGV.h
index 72847df2eea..30513946040 100644
--- a/ACE/ace/ARGV.h
+++ b/ACE/ace/ARGV.h
@@ -35,7 +35,7 @@ class ACE_ARGV_Queue_Entry_T
 {
 public:
   /// Initialize a ACE_ARGV_Queue_Entry_T.
-  ACE_ARGV_Queue_Entry_T (void);
+  ACE_ARGV_Queue_Entry_T ();
 
   /**
    * Initialize a ACE_ARGV_Queue_Entry_T.
@@ -61,10 +61,10 @@ public:
 
   /// We need this destructor to keep some compilers from complaining.
   /// It's just a no-op, however.
-  ~ACE_ARGV_Queue_Entry_T (void);
+  ~ACE_ARGV_Queue_Entry_T ();
 
   /// Dump the state of this object.
-  void dump (void) const;
+  void dump () const;
 
   // Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -194,7 +194,7 @@ public:
   explicit ACE_ARGV_T (bool substitute_env_args = true);
 
   /// Destructor.
-  ~ACE_ARGV_T (void);
+  ~ACE_ARGV_T ();
 
   /** @name Accessor methods
    *
@@ -216,22 +216,22 @@ public:
    * maintained internally to this class. Do not change or delete either the
    * pointers or the memory to which they refer.
    */
-  CHAR_TYPE **argv (void);
+  CHAR_TYPE **argv ();
 
   /// Returns the current number of arguments.
-  int argc (void) const;
+  int argc () const;
 
   /**
    * Returns a single string form of the current arguments. The returned
    * pointer refers to memory maintained internally to this class. Do not
    * change or delete it.
    */
-  const CHAR_TYPE *buf (void);
+  const CHAR_TYPE *buf ();
 
   //@}
 
   /// Dump the state of this object.
-  void dump (void) const;
+  void dump () const;
 
   // Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -282,10 +282,10 @@ private:
   ACE_ARGV_T operator= (ACE_ARGV_T<CHAR_TYPE>&&) = delete;
 
   /// Creates buf_ from the queue of added args, deletes previous buf_.
-  int create_buf_from_queue (void);
+  int create_buf_from_queue ();
 
   /// Converts buf_ into the CHAR_TYPE *argv[] format.
-  int string_to_argv (void);
+  int string_to_argv ();
 
   /// Replace args with environment variable values?
   bool substitute_env_args_;
diff --git a/ACE/ace/ARGV.inl b/ACE/ace/ARGV.inl
index cd538e9ec5c..43dfa8cf770 100644
--- a/ACE/ace/ARGV.inl
+++ b/ACE/ace/ARGV.inl
@@ -5,7 +5,7 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 template <typename CHAR_TYPE> ACE_INLINE
-ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::ACE_ARGV_Queue_Entry_T (void)
+ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::ACE_ARGV_Queue_Entry_T ()
   : arg_(0),
     quote_arg_(false)
 {
@@ -30,7 +30,7 @@ ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::ACE_ARGV_Queue_Entry_T (const ACE_ARGV_Queue_
 }
 
 template <typename CHAR_TYPE> ACE_INLINE
-ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::~ACE_ARGV_Queue_Entry_T (void)
+ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::~ACE_ARGV_Queue_Entry_T ()
 {
   // No-op just to keep some compilers happy...
 }
@@ -38,7 +38,7 @@ ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::~ACE_ARGV_Queue_Entry_T (void)
 // Return the number of args
 template <typename CHAR_TYPE>
 ACE_INLINE int
-ACE_ARGV_T<CHAR_TYPE>::argc (void) const
+ACE_ARGV_T<CHAR_TYPE>::argc () const
 {
   ACE_TRACE ("ACE_ARGV_T::argc");
  // Try to create the argv_ if it isn't there
@@ -51,7 +51,7 @@ ACE_ARGV_T<CHAR_TYPE>::argc (void) const
 // Return the arguments in a space-separated string
 template <typename CHAR_TYPE>
 ACE_INLINE const CHAR_TYPE *
-ACE_ARGV_T<CHAR_TYPE>::buf (void)
+ACE_ARGV_T<CHAR_TYPE>::buf ()
 {
   ACE_TRACE ("ACE_ARGV_T::buf");
 
@@ -65,7 +65,7 @@ ACE_ARGV_T<CHAR_TYPE>::buf (void)
 
 template <typename CHAR_TYPE>
 ACE_INLINE CHAR_TYPE **
-ACE_ARGV_T<CHAR_TYPE>::argv (void)
+ACE_ARGV_T<CHAR_TYPE>::argv ()
 {
   ACE_TRACE ("ACE_ARGV_T::argv");
 
diff --git a/ACE/ace/Argv_Type_Converter.h b/ACE/ace/Argv_Type_Converter.h
index c2a73f2c1eb..f752633de56 100644
--- a/ACE/ace/Argv_Type_Converter.h
+++ b/ACE/ace/Argv_Type_Converter.h
@@ -43,16 +43,16 @@ public:
   ACE_Argv_Type_Converter (int &argc, wchar_t** argv);
 #endif  // ACE_USES_WCHAR
 
-  ~ACE_Argv_Type_Converter (void);
+  ~ACE_Argv_Type_Converter ();
 
   /// Returns the pointer of converted command line.
-  ACE_TCHAR** get_TCHAR_argv (void);
+  ACE_TCHAR** get_TCHAR_argv ();
 
   /// Returns the pointer of ASCII (char) command line.
-  char** get_ASCII_argv (void);
+  char** get_ASCII_argv ();
 
   /// Returns the number of sub parameters (argc).
-  int& get_argc (void);
+  int& get_argc ();
 
 private:
   /// Copy Constructor should not be used.
diff --git a/ACE/ace/Argv_Type_Converter.inl b/ACE/ace/Argv_Type_Converter.inl
index 8c7bc89ca89..c79688cd723 100644
--- a/ACE/ace/Argv_Type_Converter.inl
+++ b/ACE/ace/Argv_Type_Converter.inl
@@ -2,7 +2,7 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_INLINE ACE_TCHAR**
-ACE_Argv_Type_Converter::get_TCHAR_argv (void)
+ACE_Argv_Type_Converter::get_TCHAR_argv ()
 {
 #if defined (ACE_USES_WCHAR)
   if (this->char_passed_)
@@ -18,7 +18,7 @@ ACE_Argv_Type_Converter::get_TCHAR_argv (void)
 }
 
 ACE_INLINE char**
-ACE_Argv_Type_Converter::get_ASCII_argv (void)
+ACE_Argv_Type_Converter::get_ASCII_argv ()
 {
 #if defined (ACE_USES_WCHAR)
   if (this->wchar_passed_)
@@ -33,7 +33,7 @@ ACE_Argv_Type_Converter::get_ASCII_argv (void)
 }
 
 ACE_INLINE int&
-ACE_Argv_Type_Converter::get_argc (void)
+ACE_Argv_Type_Converter::get_argc ()
 {
   return this->saved_argc_;
 }
diff --git a/ACE/ace/Bound_Ptr.h b/ACE/ace/Bound_Ptr.h
index d53b911c79c..ab39bc10623 100644
--- a/ACE/ace/Bound_Ptr.h
+++ b/ACE/ace/Bound_Ptr.h
@@ -39,11 +39,11 @@ public:
   ACE_ALLOC_HOOK_DECLARE;
 
   ACE_Bound_Ptr_Counter (long init_obj_ref_count = 0);
-  ~ACE_Bound_Ptr_Counter (void);
+  ~ACE_Bound_Ptr_Counter ();
 
   /// Create a ACE_Bound_Ptr_Counter<ACE_LOCK> and initialize the
   /// reference count to indicate ownership by a strong pointer.
-  static ACE_Bound_Ptr_Counter<ACE_LOCK> *create_strong (void);
+  static ACE_Bound_Ptr_Counter<ACE_LOCK> *create_strong ();
 
   /// Increase both the object and counter reference counts and return
   /// the new object reference count. A return value of -1 indicates
@@ -57,7 +57,7 @@ public:
 
   /// Create a ACE_Bound_Ptr_Counter<ACE_LOCK> and initialize the
   /// reference count to indicate no ownership.
-  static ACE_Bound_Ptr_Counter<ACE_LOCK> *create_weak (void);
+  static ACE_Bound_Ptr_Counter<ACE_LOCK> *create_weak ();
 
   /// Increase the counter reference count and return argument.
   static void attach_weak (ACE_Bound_Ptr_Counter<ACE_LOCK> *counter);
@@ -130,7 +130,7 @@ public:
   }
 
   /// Destructor.
-  ~ACE_Strong_Bound_Ptr (void);
+  ~ACE_Strong_Bound_Ptr ();
 
   /// Assignment operator that binds @c this and @a r to the same object.
   void operator = (const ACE_Strong_Bound_Ptr<X, ACE_LOCK> &r);
@@ -194,13 +194,13 @@ public:
   bool operator != (X *p) const;
 
   /// Redirection operator
-  X *operator-> (void) const;
+  X *operator-> () const;
 
   /// Dereference operator
-  X &operator * (void) const;
+  X &operator * () const;
 
   /// Get the pointer value.
-  X *get (void) const;
+  X *get () const;
 
   /// Resets the ACE_Strong_Bound_Ptr to refer to a different
   /// underlying object.
@@ -208,7 +208,7 @@ public:
 
   /// Allows us to check for NULL on all ACE_Strong_Bound_Ptr
   /// objects.
-  bool null (void) const;
+  bool null () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -262,7 +262,7 @@ public:
   ACE_Weak_Bound_Ptr (const ACE_Strong_Bound_Ptr<X, ACE_LOCK> &r);
 
   /// Destructor.
-  ~ACE_Weak_Bound_Ptr (void);
+  ~ACE_Weak_Bound_Ptr ();
 
   /// Assignment operator that binds @c this and @a r to the same object.
   void operator = (const ACE_Weak_Bound_Ptr<X, ACE_LOCK> &r);
@@ -308,17 +308,17 @@ public:
    * certain of the lifetimes of the object, and do not want to incur
    * the locking overhead, then use the unsafe_get method instead.
    */
-  ACE_Strong_Bound_Ptr<X, ACE_LOCK> operator-> (void) const;
+  ACE_Strong_Bound_Ptr<X, ACE_LOCK> operator-> () const;
 
   /// Obtain a strong pointer corresponding to this weak pointer. This
   /// function is useful to create a temporary strong pointer for
   /// conversion to a reference.
-  ACE_Strong_Bound_Ptr<X, ACE_LOCK> strong (void) const;
+  ACE_Strong_Bound_Ptr<X, ACE_LOCK> strong () const;
 
   /// Get the pointer value. Warning: this does not affect the
   /// reference count of the underlying object, so it may disappear on
   /// you while you are using it if you are not careful.
-  X *unsafe_get (void) const;
+  X *unsafe_get () const;
 
   /// Resets the ACE_Weak_Bound_Ptr to refer to a different underlying
   /// object.
@@ -331,7 +331,7 @@ public:
    * reference counting mechanism such as those used by COM or CORBA
    * servants.
    */
-  long add_ref (void);
+  long add_ref ();
 
   /// Decrement the reference count on the underlying object, which is deleted
   /// if the count has reached zero.
@@ -341,10 +341,10 @@ public:
    * reference counting mechanism such as those used by COM or CORBA
    * servants.
    */
-  long remove_ref (void);
+  long remove_ref ();
 
   /// Allows us to check for NULL on all ACE_Weak_Bound_Ptr objects.
-  bool null (void) const;
+  bool null () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
diff --git a/ACE/ace/Bound_Ptr.inl b/ACE/ace/Bound_Ptr.inl
index ff9e6e338ed..c5699e84030 100644
--- a/ACE/ace/Bound_Ptr.inl
+++ b/ACE/ace/Bound_Ptr.inl
@@ -17,7 +17,7 @@ ACE_Bound_Ptr_Counter<ACE_LOCK>::internal_create (long init_obj_ref_count)
 }
 
 template <class ACE_LOCK> inline ACE_Bound_Ptr_Counter<ACE_LOCK> *
-ACE_Bound_Ptr_Counter<ACE_LOCK>::create_strong (void)
+ACE_Bound_Ptr_Counter<ACE_LOCK>::create_strong ()
 {
   // Set initial object reference count to 1.
   ACE_Bound_Ptr_Counter<ACE_LOCK> *temp = internal_create (1);
@@ -77,7 +77,7 @@ ACE_Bound_Ptr_Counter<ACE_LOCK>::detach_strong (ACE_Bound_Ptr_Counter<ACE_LOCK>*
 }
 
 template <class ACE_LOCK> inline ACE_Bound_Ptr_Counter<ACE_LOCK> *
-ACE_Bound_Ptr_Counter<ACE_LOCK>::create_weak (void)
+ACE_Bound_Ptr_Counter<ACE_LOCK>::create_weak ()
 {
   // Set initial object reference count to 0.
 
@@ -135,7 +135,7 @@ ACE_Bound_Ptr_Counter<ACE_LOCK>::ACE_Bound_Ptr_Counter (long init_obj_ref_count)
 }
 
 template <class ACE_LOCK> inline
-ACE_Bound_Ptr_Counter<ACE_LOCK>::~ACE_Bound_Ptr_Counter (void)
+ACE_Bound_Ptr_Counter<ACE_LOCK>::~ACE_Bound_Ptr_Counter ()
 {
 }
 
@@ -171,7 +171,7 @@ ACE_Strong_Bound_Ptr<X, ACE_LOCK>::ACE_Strong_Bound_Ptr (const ACE_Weak_Bound_Pt
 }
 
 template <class X, class ACE_LOCK> inline
-ACE_Strong_Bound_Ptr<X, ACE_LOCK>::~ACE_Strong_Bound_Ptr (void)
+ACE_Strong_Bound_Ptr<X, ACE_LOCK>::~ACE_Strong_Bound_Ptr ()
 {
   if (COUNTER::detach_strong (this->counter_) == 0)
     delete this->ptr_;
@@ -260,7 +260,7 @@ ACE_Strong_Bound_Ptr<X, ACE_LOCK>::operator!= (X *p) const
 }
 
 template <class X, class ACE_LOCK> inline X *
-ACE_Strong_Bound_Ptr<X, ACE_LOCK>::operator-> (void) const
+ACE_Strong_Bound_Ptr<X, ACE_LOCK>::operator-> () const
 {
   return this->ptr_;
 }
@@ -272,13 +272,13 @@ ACE_Strong_Bound_Ptr<X, ACE_LOCK>::operator *() const
 }
 
 template <class X, class ACE_LOCK> inline X*
-ACE_Strong_Bound_Ptr<X, ACE_LOCK>::get (void) const
+ACE_Strong_Bound_Ptr<X, ACE_LOCK>::get () const
 {
   return this->ptr_;
 }
 
 template <class X, class ACE_LOCK> inline bool
-ACE_Strong_Bound_Ptr<X, ACE_LOCK>::null (void) const
+ACE_Strong_Bound_Ptr<X, ACE_LOCK>::null () const
 {
   return this->ptr_ == 0;
 }
@@ -318,7 +318,7 @@ ACE_Weak_Bound_Ptr<X, ACE_LOCK>::ACE_Weak_Bound_Ptr (const ACE_Strong_Bound_Ptr<
 }
 
 template <class X, class ACE_LOCK> inline
-ACE_Weak_Bound_Ptr<X, ACE_LOCK>::~ACE_Weak_Bound_Ptr (void)
+ACE_Weak_Bound_Ptr<X, ACE_LOCK>::~ACE_Weak_Bound_Ptr ()
 {
   COUNTER::detach_weak (this->counter_);
 }
@@ -412,19 +412,19 @@ ACE_Weak_Bound_Ptr<X, ACE_LOCK>::operator!= (X *p) const
 }
 
 template <class X, class ACE_LOCK> inline ACE_Strong_Bound_Ptr<X, ACE_LOCK>
-ACE_Weak_Bound_Ptr<X, ACE_LOCK>::operator-> (void) const
+ACE_Weak_Bound_Ptr<X, ACE_LOCK>::operator-> () const
 {
   return ACE_Strong_Bound_Ptr<X, ACE_LOCK> (*this);
 }
 
 template <class X, class ACE_LOCK> inline ACE_Strong_Bound_Ptr<X, ACE_LOCK>
-ACE_Weak_Bound_Ptr<X, ACE_LOCK>::strong (void) const
+ACE_Weak_Bound_Ptr<X, ACE_LOCK>::strong () const
 {
   return ACE_Strong_Bound_Ptr<X, ACE_LOCK> (*this);
 }
 
 template <class X, class ACE_LOCK> inline X*
-ACE_Weak_Bound_Ptr<X, ACE_LOCK>::unsafe_get (void) const
+ACE_Weak_Bound_Ptr<X, ACE_LOCK>::unsafe_get () const
 {
   // We do not check if the object has been deleted, since this operation
   // is defined to be unsafe!
@@ -432,7 +432,7 @@ ACE_Weak_Bound_Ptr<X, ACE_LOCK>::unsafe_get (void) const
 }
 
 template <class X, class ACE_LOCK> inline bool
-ACE_Weak_Bound_Ptr<X, ACE_LOCK>::null (void) const
+ACE_Weak_Bound_Ptr<X, ACE_LOCK>::null () const
 {
   // A weak pointer must behave as though it is automatically set to null
   // if the underlying object has been deleted.
diff --git a/ACE/ace/Dirent.h b/ACE/ace/Dirent.h
index 65fe3049bb5..02551013d07 100644
--- a/ACE/ace/Dirent.h
+++ b/ACE/ace/Dirent.h
@@ -34,7 +34,7 @@ class ACE_Export ACE_Dirent
 {
 public:
   /// Default constructor.
-  ACE_Dirent (void);
+  ACE_Dirent ();
 
   /// Constructor calls @c opendir()
   explicit ACE_Dirent (const ACE_TCHAR *dirname);
@@ -44,10 +44,10 @@ public:
   int open (const ACE_TCHAR *filename);
 
   /// Destructor calls @c closedir().
-  ~ACE_Dirent (void);
+  ~ACE_Dirent ();
 
   /// Closes the directory stream and frees the ACE_DIR structure.
-  void close (void);
+  void close ();
 
   // = Iterator methods.
   /**
@@ -67,12 +67,12 @@ public:
    * update the st_atime field of the directory each time the
    * directory is actually read.
    */
-  ACE_DIRENT *read (void);
+  ACE_DIRENT *read ();
 
   // = Manipulators.
   /// Returns the current location associated with the directory
   /// stream.
-  long tell (void);
+  long tell ();
 
   /**
    * Sets the position of the next @c read() operation on the
@@ -94,7 +94,7 @@ public:
    * the current state of the corresponding directory, as a call to
    * @c opendir() would.
    */
-  void rewind (void);
+  void rewind ();
 
 private:
   /// Pointer to the directory stream.
diff --git a/ACE/ace/Dirent.inl b/ACE/ace/Dirent.inl
index 24befd9f975..163954c712f 100644
--- a/ACE/ace/Dirent.inl
+++ b/ACE/ace/Dirent.inl
@@ -24,7 +24,7 @@ ACE_Dirent::open (const ACE_TCHAR *dirname)
 }
 
 ACE_INLINE
-ACE_Dirent::ACE_Dirent (void)
+ACE_Dirent::ACE_Dirent ()
   : dirp_ (0)
 {
 }
@@ -40,20 +40,20 @@ ACE_Dirent::ACE_Dirent (const ACE_TCHAR *dirname)
 }
 
 ACE_INLINE
-ACE_Dirent::~ACE_Dirent (void)
+ACE_Dirent::~ACE_Dirent ()
 {
   if (this->dirp_ != 0)
     ACE_OS::closedir (this->dirp_);
 }
 
 ACE_INLINE ACE_DIRENT *
-ACE_Dirent::read (void)
+ACE_Dirent::read ()
 {
   return this->dirp_ ? ACE_OS::readdir (this->dirp_) : 0;
 }
 
 ACE_INLINE void
-ACE_Dirent::close (void)
+ACE_Dirent::close ()
 {
   if (this->dirp_ != 0)
     {
@@ -65,7 +65,7 @@ ACE_Dirent::close (void)
 }
 
 ACE_INLINE void
-ACE_Dirent::rewind (void)
+ACE_Dirent::rewind ()
 {
   if (this->dirp_)
     ACE_OS::rewinddir (this->dirp_);
@@ -79,7 +79,7 @@ ACE_Dirent::seek (long loc)
 }
 
 ACE_INLINE long
-ACE_Dirent::tell (void)
+ACE_Dirent::tell ()
 {
   return this->dirp_ ? ACE_OS::telldir (this->dirp_) : 0;
 }
diff --git a/ACE/ace/Env_Value_T.h b/ACE/ace/Env_Value_T.h
index 4e268d3f933..6e97e3602d7 100644
--- a/ACE/ace/Env_Value_T.h
+++ b/ACE/ace/Env_Value_T.h
@@ -44,26 +44,26 @@ public:
    * variable name or a default value.  Before being useful it must
    * open()'d.
    */
-  ACE_Env_Value (void);
+  ACE_Env_Value ();
 
   /// Constructor that calls open().
   ACE_Env_Value (const ACE_TCHAR *varname, const T &vardefault);
 
   /// Destroy the value.
-  ~ACE_Env_Value (void);
+  ~ACE_Env_Value ();
 
   /// Returns the value as type T.
-  operator T (void);
+  operator T ();
 
   /// The constructor, read @a varname from the environment, using
   /// @a defval as its value if it is not defined.
   void open (const ACE_TCHAR *varname, const T &defval);
 
   /// Returns the name of the variable being tracked.
-  const ACE_TCHAR *varname (void) const;
+  const ACE_TCHAR *varname () const;
 
 private:
-  void fetch_value (void);
+  void fetch_value ();
 
   const ACE_TCHAR *varname_;
   T value_;
diff --git a/ACE/ace/Env_Value_T.inl b/ACE/ace/Env_Value_T.inl
index 1fc1b863f03..f016e5c5f68 100644
--- a/ACE/ace/Env_Value_T.inl
+++ b/ACE/ace/Env_Value_T.inl
@@ -1,13 +1,13 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 template <class T> ACE_INLINE
-ACE_Env_Value<T>::operator T (void)
+ACE_Env_Value<T>::operator T ()
 {
   return value_;
 }
 
 template <class T> ACE_INLINE
-ACE_Env_Value<T>::ACE_Env_Value (void)
+ACE_Env_Value<T>::ACE_Env_Value ()
   : varname_ (0)
 {
 }
@@ -31,7 +31,7 @@ ACE_Env_Value<T>::open (const ACE_TCHAR *varname,
 }
 
 template <class T> ACE_INLINE void
-ACE_Env_Value<T>::fetch_value (void)
+ACE_Env_Value<T>::fetch_value ()
 {
 #if defined (ACE_WIN32)
   const ACE_TCHAR *env = ACE_OS::getenv (this->varname_);
@@ -45,13 +45,13 @@ ACE_Env_Value<T>::fetch_value (void)
 }
 
 template <class T> ACE_INLINE const ACE_TCHAR*
-ACE_Env_Value<T>::varname (void) const
+ACE_Env_Value<T>::varname () const
 {
   return this->varname_;
 }
 
 template <class T> ACE_INLINE
-ACE_Env_Value<T>::~ACE_Env_Value (void)
+ACE_Env_Value<T>::~ACE_Env_Value ()
 {
 }
 
diff --git a/ACE/ace/Handle_Set.h b/ACE/ace/Handle_Set.h
index 4e4cf36ab94..33a9728a62d 100644
--- a/ACE/ace/Handle_Set.h
+++ b/ACE/ace/Handle_Set.h
@@ -63,7 +63,7 @@ public:
   };
 
   /// Constructor, initializes the bitmask to all 0s.
-  ACE_Handle_Set (void);
+  ACE_Handle_Set ();
 
   /**
    * Constructor, initializes the handle set from a given mask.
@@ -72,7 +72,7 @@ public:
 
   // = Methods for manipulating bitsets.
   /// Initialize the bitmask to all 0s and reset the associated fields.
-  void reset (void);
+  void reset ();
 
   /**
    * Checks whether @a handle is enabled.  No range checking is
@@ -90,10 +90,10 @@ public:
   void clr_bit (ACE_HANDLE handle);
 
   /// Returns a count of the number of enabled bits.
-  int num_set (void) const;
+  int num_set () const;
 
   /// Returns the number of the large bit.
-  ACE_HANDLE max_set (void) const;
+  ACE_HANDLE max_set () const;
 
   /**
    * Rescan the underlying @c fd_set up to handle @a max to find the new
@@ -110,7 +110,7 @@ public:
 
   /// Returns a pointer to the underlying @c fd_set.  Returns 0 if
   /// there are no handle bits set (<size_> == 0).
-  fd_set *fdset (void);
+  fd_set *fdset ();
 
 #if defined (ACE_HAS_BIG_FD_SET)
   /// Assignment operator optimizes for cases where <size_> == 0.
@@ -118,7 +118,7 @@ public:
 #endif /* ACE_HAS_BIG_FD_SET */
 
   /// Dump the state of an object.
-  void dump (void) const;
+  void dump () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -177,11 +177,11 @@ public:
   ACE_Handle_Set_Iterator (const ACE_Handle_Set &hs);
 
   /// Default dtor.
-  ~ACE_Handle_Set_Iterator (void);
+  ~ACE_Handle_Set_Iterator ();
 
   /// Reset the state of the iterator by reinitializing the state
   /// that we maintain.
-  void reset_state (void);
+  void reset_state ();
 
   /**
    * "Next" operator.  Returns the next unseen ACE_HANDLE in the
@@ -190,10 +190,10 @@ public:
    * the iterator automatically, so you need not call <operator++>
    * (which is now obsolete).
    */
-  ACE_HANDLE operator () (void);
+  ACE_HANDLE operator () ();
 
   /// Dump the state of an object.
-  void dump (void) const;
+  void dump () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
diff --git a/ACE/ace/Handle_Set.inl b/ACE/ace/Handle_Set.inl
index db76152f168..c156c78c846 100644
--- a/ACE/ace/Handle_Set.inl
+++ b/ACE/ace/Handle_Set.inl
@@ -11,7 +11,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 // Initialize the bitmask to all 0s and reset the associated fields.
 
 ACE_INLINE void
-ACE_Handle_Set::reset (void)
+ACE_Handle_Set::reset ()
 {
   ACE_TRACE ("ACE_Handle_Set::reset");
   this->max_handle_ =
@@ -53,7 +53,7 @@ ACE_Handle_Set::operator = (const ACE_Handle_Set &rhs)
 // Returns the number of the large bit.
 
 ACE_INLINE ACE_HANDLE
-ACE_Handle_Set::max_set (void) const
+ACE_Handle_Set::max_set () const
 {
   ACE_TRACE ("ACE_Handle_Set::max_set");
   return this->max_handle_;
@@ -133,7 +133,7 @@ ACE_Handle_Set::clr_bit (ACE_HANDLE handle)
 // Returns a count of the number of enabled bits.
 
 ACE_INLINE int
-ACE_Handle_Set::num_set (void) const
+ACE_Handle_Set::num_set () const
 {
   ACE_TRACE ("ACE_Handle_Set::num_set");
 #if defined (ACE_HANDLE_SET_USES_FD_ARRAY)
@@ -159,7 +159,7 @@ ACE_Handle_Set::operator fd_set *()
 // Returns a pointer to the underlying fd_set.
 
 ACE_INLINE fd_set *
-ACE_Handle_Set::fdset (void)
+ACE_Handle_Set::fdset ()
 {
   ACE_TRACE ("ACE_Handle_Set::fdset");
 
@@ -170,7 +170,7 @@ ACE_Handle_Set::fdset (void)
 }
 
 ACE_INLINE
-ACE_Handle_Set_Iterator::~ACE_Handle_Set_Iterator (void)
+ACE_Handle_Set_Iterator::~ACE_Handle_Set_Iterator ()
 {
 }
 
diff --git a/ACE/ace/Process.h b/ACE/ace/Process.h
index 1d20817f7cd..90adcae52fc 100644
--- a/ACE/ace/Process.h
+++ b/ACE/ace/Process.h
@@ -86,7 +86,7 @@ public:
                        size_t max_cmdline_args = MAX_COMMAND_LINE_OPTIONS);
 
   /// Destructor.
-  ~ACE_Process_Options (void);
+  ~ACE_Process_Options ();
 
   // = Methods to set process creation options portably.
 
@@ -112,7 +112,7 @@ public:
                    ACE_HANDLE std_err = ACE_INVALID_HANDLE);
 
   /// Release the standard handles previously set with set_handles;
-  void release_handles (void);
+  void release_handles ();
 
 #ifndef ACE_LACKS_VA_FUNCTIONS
   /// @param format must be of the form "VARIABLE=VALUE".  There can not be
@@ -189,10 +189,10 @@ public:
 
   /// Return the process_name.  If the <process_name(name)> set
   /// method is not called, this method will return argv[0].
-  const ACE_TCHAR *process_name (void);
+  const ACE_TCHAR *process_name ();
 
   /// Get the creation flags.
-  u_long creation_flags (void) const;
+  u_long creation_flags () const;
 
   /**
    * Set the creation flags to affect how a new process is spawned.
@@ -208,7 +208,7 @@ public:
   void creation_flags (u_long);
 
   /// Current working directory.  Returns "" if nothing has been set.
-  ACE_TCHAR *working_directory (void);
+  ACE_TCHAR *working_directory ();
 
   /// Buffer of command-line options.  Returns a pointer to a buffer that
   /// contains the list of command line options.  Prior to a call to
@@ -229,18 +229,18 @@ public:
    * and returned with each entry pointing to the start of
    * null-terminated string.  Returns { 0 } if nothing has been set.
    */
-  ACE_TCHAR * const *command_line_argv (void);
+  ACE_TCHAR * const *command_line_argv ();
 
   /**
    * Null-terminated buffer of null terminated strings.  Each string
    * is an environment assignment "VARIABLE=value".  This buffer
    * should end with two null characters.
    */
-  ACE_TCHAR *env_buf (void);
+  ACE_TCHAR *env_buf ();
 
   /// Get the process group.  On UNIX, these methods are used by the
   /// ACE_Process_Manager to manage groups of processes.
-  pid_t getgroup (void) const;
+  pid_t getgroup () const;
 
   /// Set the process group.  On UNIX, these methods are used by the
   /// ACE_Process_Manager to manage groups of processes.
@@ -254,7 +254,7 @@ public:
   /// ACE_Process_Options::set_handles() you must not call
   /// handle_inheritance(false). Doing so will prevent the duplicated handles
   /// from surviving in the created process.
-  int handle_inheritance (void);
+  int handle_inheritance ();
   void handle_inheritance (int);
 
   /// Cause the specified handle to be passed to a child process
@@ -291,17 +291,17 @@ public:
   void avoid_zombies (int);
 
   /// Get current value for avoid_zombies.
-  int avoid_zombies (void);
+  int avoid_zombies ();
 
   /// Enable the use of a Unicode environment.  This only makes sense
   /// for Win32 when ACE_USES_WCHAR is not defined.
-  void enable_unicode_environment (void);
+  void enable_unicode_environment ();
 
   /// Disable the use of a Unicode environment.
-  void disable_unicode_environment (void);
+  void disable_unicode_environment ();
 
   /// Return the unicode environment status
-  bool use_unicode_environment (void) const;
+  bool use_unicode_environment () const;
 
 #if defined (ACE_WIN32)
   // = Non-portable accessors for when you "just have to use them."
@@ -336,12 +336,12 @@ public:
 #else /* All things not WIN32 */
 
   /// argv-style array of environment settings.
-  ACE_TCHAR *const *env_argv (void);
+  ACE_TCHAR *const *env_argv ();
 
   // = Accessors for the standard handles.
-  ACE_HANDLE get_stdin (void) const;
-  ACE_HANDLE get_stdout (void) const;
-  ACE_HANDLE get_stderr (void) const;
+  ACE_HANDLE get_stdin () const;
+  ACE_HANDLE get_stdout () const;
+  ACE_HANDLE get_stderr () const;
 
   // = Set/get real & effective user & group id associated with user.
   int setreugid (const ACE_TCHAR* user);
@@ -349,15 +349,15 @@ public:
   void seteuid (uid_t id);
   void setrgid (uid_t id);
   void setegid (uid_t id);
-  uid_t getruid (void) const;
-  uid_t geteuid (void) const;
-  uid_t getrgid (void) const;
-  uid_t getegid (void) const;
+  uid_t getruid () const;
+  uid_t geteuid () const;
+  uid_t getrgid () const;
+  uid_t getegid () const;
 
   /**
    * Get the inherit_environment flag.
    */
-  bool inherit_environment (void) const;
+  bool inherit_environment () const;
 
   /**
    * Set the inherit_environment flag.
@@ -517,10 +517,10 @@ public:
   friend class ACE_Process_Manager;
 
   /// Default construction.  Use ACE_Process::spawn() to start a process.
-  ACE_Process (void);
+  ACE_Process ();
 
   /// Destructor.
-  virtual ~ACE_Process (void);
+  virtual ~ACE_Process ();
 
   /**
    * Called back from spawn() just before spawning the child.  If this
@@ -563,7 +563,7 @@ public:
 
   /// Called by a ACE_Process_Manager that is removing this object from
   /// its table of managed processes. Default is to do nothing.
-  virtual void unmanage (void);
+  virtual void unmanage ();
 
   /**
    * Wait for a previously spawned process to exit.
@@ -608,34 +608,34 @@ public:
    * This call doesn't give the process a chance to cleanup, so use it
    * with caution.
    */
-  int terminate (void);
+  int terminate ();
 
   /// Return the process id of the new child process.
-  pid_t getpid (void) const;
+  pid_t getpid () const;
 
   /// Return the handle of the process, if it has one.
-  ACE_HANDLE gethandle (void) const;
+  ACE_HANDLE gethandle () const;
 
   /// Return 1 if running; 0 otherwise.
-  int running (void) const;
+  int running () const;
 
   /// Return the process's exit code.  This method returns the raw
   /// exit status returned from system APIs (such as @c wait() or
   /// @c waitpid() ).  This value is system dependent.
-  ACE_exitcode exit_code (void) const;
+  ACE_exitcode exit_code () const;
 
   /// Return the process's return value.  This method returns the
   /// actual return value that a child process returns or exits with.
-  int return_value (void) const;
+  int return_value () const;
 
   /// Close all the handles in the set obtained from the
   /// @a ACE_Process_Options::dup_handles object used to spawn
   /// the process.
-  void close_dup_handles (void);
+  void close_dup_handles ();
 
   /// Close all the passed handles in the set obtained from the
   /// ACE_Process_Options object used to spawn the process.
-  void close_passed_handles (void);
+  void close_passed_handles ();
 
 #if defined (ACE_WIN32)
   PROCESS_INFORMATION process_info (void);
@@ -689,14 +689,14 @@ class ACE_Export ACE_Managed_Process : public ACE_Process
 public:
 
   /// Cleanup by deleting @c this.
-  virtual void unmanage (void);
+  virtual void unmanage ();
 
   ACE_ALLOC_HOOK_DECLARE;
 
 protected:
 
   /// Make sure that we're allocated dynamically!
-  virtual ~ACE_Managed_Process (void);
+  virtual ~ACE_Managed_Process ();
 };
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ACE/ace/Process.inl b/ACE/ace/Process.inl
index 66241f43661..f1bacf8d431 100644
--- a/ACE/ace/Process.inl
+++ b/ACE/ace/Process.inl
@@ -8,19 +8,19 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_INLINE void
-ACE_Process_Options::enable_unicode_environment (void)
+ACE_Process_Options::enable_unicode_environment ()
 {
   this->use_unicode_environment_ = true;
 }
 
 ACE_INLINE void
-ACE_Process_Options::disable_unicode_environment (void)
+ACE_Process_Options::disable_unicode_environment ()
 {
   this->use_unicode_environment_ = false;
 }
 
 ACE_INLINE bool
-ACE_Process_Options::use_unicode_environment (void) const
+ACE_Process_Options::use_unicode_environment () const
 {
   return this->use_unicode_environment_;
 }
@@ -35,7 +35,7 @@ ACE_Process::process_info (void)
 #endif /* ACE_WIN32 */
 
 ACE_INLINE ACE_HANDLE
-ACE_Process::gethandle (void) const
+ACE_Process::gethandle () const
 {
 #if defined (ACE_WIN32)
   return process_info_.hProcess;
@@ -45,7 +45,7 @@ ACE_Process::gethandle (void) const
 }
 
 ACE_INLINE pid_t
-ACE_Process::getpid (void) const
+ACE_Process::getpid () const
 {
 #if defined (ACE_WIN32)
   return process_info_.dwProcessId;
@@ -82,7 +82,7 @@ ACE_Process::kill (int signum)
 }
 
 ACE_INLINE int
-ACE_Process::terminate (void)
+ACE_Process::terminate ()
 {
   if (this->getpid () != -1)
     return ACE::terminate_process (this->getpid ());
@@ -91,7 +91,7 @@ ACE_Process::terminate (void)
 }
 
 ACE_INLINE int
-ACE_Process::return_value (void) const
+ACE_Process::return_value () const
 {
 #if defined (ACE_WIN32)
   return this->exit_code_;
@@ -101,7 +101,7 @@ ACE_Process::return_value (void) const
 }
 
 ACE_INLINE ACE_exitcode
-ACE_Process::exit_code (void) const
+ACE_Process::exit_code () const
 {
   return this->exit_code_;
 }
@@ -113,7 +113,7 @@ ACE_Process::exit_code (ACE_exitcode code)
 }
 
 ACE_INLINE u_long
-ACE_Process_Options::creation_flags (void) const
+ACE_Process_Options::creation_flags () const
 {
 #if defined (ACE_USES_WCHAR) && defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
   return creation_flags_ | CREATE_UNICODE_ENVIRONMENT;
@@ -129,7 +129,7 @@ ACE_Process_Options::creation_flags (u_long cf)
 }
 
 ACE_INLINE pid_t
-ACE_Process_Options::getgroup (void) const
+ACE_Process_Options::getgroup () const
 {
   return process_group_;
 }
@@ -143,7 +143,7 @@ ACE_Process_Options::setgroup (pid_t pgrp)
 }
 
 ACE_INLINE int
-ACE_Process_Options::handle_inheritance (void)
+ACE_Process_Options::handle_inheritance ()
 {
   return handle_inheritance_;
 }
@@ -155,7 +155,7 @@ ACE_Process_Options::handle_inheritance (int hi)
 }
 
 ACE_INLINE int
-ACE_Process_Options::avoid_zombies (void)
+ACE_Process_Options::avoid_zombies ()
 {
   return avoid_zombies_;
 }
@@ -227,25 +227,25 @@ ACE_INLINE HANDLE ACE_Process_Options::get_user_token (void) const
 #else /* !defined (ACE_WIN32) */
 
 ACE_INLINE ACE_HANDLE
-ACE_Process_Options::get_stdin (void) const
+ACE_Process_Options::get_stdin () const
 {
   return stdin_;
 }
 
 ACE_INLINE ACE_HANDLE
-ACE_Process_Options::get_stdout (void) const
+ACE_Process_Options::get_stdout () const
 {
   return stdout_;
 }
 
 ACE_INLINE ACE_HANDLE
-ACE_Process_Options::get_stderr (void) const
+ACE_Process_Options::get_stderr () const
 {
   return stderr_;
 }
 
 ACE_INLINE bool
-ACE_Process_Options::inherit_environment (void) const
+ACE_Process_Options::inherit_environment () const
 {
   return inherit_environment_;
 }
@@ -303,25 +303,25 @@ ACE_Process_Options::setegid (uid_t id)
 }
 
 ACE_INLINE uid_t
-ACE_Process_Options::getruid (void) const
+ACE_Process_Options::getruid () const
 {
   return this->ruid_;
 }
 
 ACE_INLINE uid_t
-ACE_Process_Options::geteuid (void) const
+ACE_Process_Options::geteuid () const
 {
   return this->euid_;
 }
 
 ACE_INLINE uid_t
-ACE_Process_Options::getrgid (void) const
+ACE_Process_Options::getrgid () const
 {
   return this->rgid_;
 }
 
 ACE_INLINE uid_t
-ACE_Process_Options::getegid (void) const
+ACE_Process_Options::getegid () const
 {
   return this->egid_;
 }
@@ -336,7 +336,7 @@ ACE_Process_Options::command_line_buf (size_t *max_lenp)
 }
 
 ACE_INLINE ACE_TCHAR *
-ACE_Process_Options::working_directory (void)
+ACE_Process_Options::working_directory ()
 {
 #if !defined (ACE_HAS_WINCE)
   if (working_directory_[0] == '\0')
@@ -377,7 +377,7 @@ ACE_Process_Options::process_name (const ACE_TCHAR *p)
 }
 
 ACE_INLINE const ACE_TCHAR *
-ACE_Process_Options::process_name (void)
+ACE_Process_Options::process_name ()
 {
   if (process_name_[0] == '\0')
     this->process_name (this->command_line_argv ()[0]);
diff --git a/ACE/ace/Process_Manager.h b/ACE/ace/Process_Manager.h
index 721fdeae978..90fc88d5472 100644
--- a/ACE/ace/Process_Manager.h
+++ b/ACE/ace/Process_Manager.h
@@ -130,11 +130,11 @@ public:
             ACE_Reactor *r = 0);
 
   /// Release all resources.  Do not wait for processes to exit.
-  int close (void);
+  int close ();
 
   /// Destructor releases all resources and does not wait for processes
   /// to exit.
-  virtual ~ACE_Process_Manager (void);
+  virtual ~ACE_Process_Manager ();
 
   //@}
 
@@ -143,14 +143,14 @@ public:
    */
   //@{
   /// Get pointer to a process-wide ACE_Process_Manager.
-  static ACE_Process_Manager *instance (void);
+  static ACE_Process_Manager *instance ();
 
   /// Set pointer to a process-wide ACE_Process_Manager and return
   /// existing pointer.
   static ACE_Process_Manager *instance (ACE_Process_Manager *);
 
   /// Delete the dynamically allocated singleton.
-  static void close_singleton (void);
+  static void close_singleton ();
 
   /// Cleanup method, used by the ACE_Object_Manager to destroy the
   /// singleton.
@@ -318,7 +318,7 @@ public:
   int remove (pid_t pid);
 
   /// Return the number of managed processes.
-  size_t managed (void) const;
+  size_t managed () const;
 
   /**
    * Sets the scheduling parameters for process identified by @a pid by
@@ -339,7 +339,7 @@ public:
   int set_scheduler_all (const ACE_Sched_Params &params);
 
   /// Dump the state of an object.
-  void dump (void) const;
+  void dump () const;
 
   /// Declare the dynamic allocation hooks.
   ACE_ALLOC_HOOK_DECLARE;
@@ -406,8 +406,8 @@ private:
   struct Process_Descriptor
   {
     /// Default ctor/dtor.
-    Process_Descriptor (void);
-    ~Process_Descriptor (void);
+    Process_Descriptor ();
+    ~Process_Descriptor ();
 
     /// Describes the process itself.
     ACE_Process *process_;
@@ -416,7 +416,7 @@ private:
     ACE_Event_Handler *exit_notify_;
 
     /// Dump the state of an object.
-    void dump (void) const;
+    void dump () const;
 
     ACE_ALLOC_HOOK_DECLARE;
   };
diff --git a/ACE/ace/Process_Manager.inl b/ACE/ace/Process_Manager.inl
index 33d2c034be7..18bbe7a4ffe 100644
--- a/ACE/ace/Process_Manager.inl
+++ b/ACE/ace/Process_Manager.inl
@@ -2,7 +2,7 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_INLINE size_t
-ACE_Process_Manager::managed (void) const
+ACE_Process_Manager::managed () const
 {
   return current_count_;
 }
diff --git a/ACE/ace/UUID.h b/ACE/ace/UUID.h
index 5ed3877da89..3745fc25fdf 100644
--- a/ACE/ace/UUID.h
+++ b/ACE/ace/UUID.h
@@ -43,12 +43,12 @@ namespace ACE_Utils
     typedef u_char Node_ID[NODE_ID_SIZE];
 
     /// Get the node id
-    Node_ID & node_ID (void);
+    Node_ID & node_ID ();
 
     /**
      * @overload
      */
-    const Node_ID & node_ID (void) const;
+    const Node_ID & node_ID () const;
 
     /// Test for equality.
     bool operator == (const UUID_Node & right) const;
@@ -86,7 +86,7 @@ namespace ACE_Utils
     enum { BINARY_SIZE = 16 };
 
     /// Constructor
-    UUID (void);
+    UUID ();
 
 #ifndef ACE_LACKS_SSCANF
     /// Constructs a UUID from a string representation.
@@ -96,36 +96,36 @@ namespace ACE_Utils
     UUID (const UUID &right);
 
     // Destructor
-    ~UUID (void);
+    ~UUID ();
 
-    ACE_UINT32 time_low (void) const;
+    ACE_UINT32 time_low () const;
     void time_low (ACE_UINT32);
 
-    ACE_UINT16 time_mid (void) const;
+    ACE_UINT16 time_mid () const;
     void time_mid (ACE_UINT16);
 
-    ACE_UINT16 time_hi_and_version (void) const;
+    ACE_UINT16 time_hi_and_version () const;
     void time_hi_and_version (ACE_UINT16);
 
-    u_char clock_seq_hi_and_reserved (void) const;
+    u_char clock_seq_hi_and_reserved () const;
     void clock_seq_hi_and_reserved (u_char);
 
-    u_char clock_seq_low (void) const;
+    u_char clock_seq_low () const;
     void clock_seq_low (u_char);
 
-    UUID_Node & node (void);
-    const UUID_Node & node (void) const;
+    UUID_Node & node ();
+    const UUID_Node & node () const;
 
     void node (const UUID_Node & node);
 
-    ACE_CString* thr_id (void);
+    ACE_CString* thr_id ();
     void thr_id (char*);
 
-    ACE_CString* pid (void);
+    ACE_CString* pid ();
     void pid (char*);
 
     /// Returns a string representation of the UUID
-    const ACE_CString* to_string (void) const;
+    const ACE_CString* to_string () const;
 
 #ifndef ACE_LACKS_SSCANF
     /// Set the value using a string
@@ -140,7 +140,7 @@ namespace ACE_Utils
     bool operator != (const UUID &right) const;
 
     /// Compute a hash value for the UUID.
-    unsigned long hash (void) const;
+    unsigned long hash () const;
 
     /// Assign an existing UUID to this UUID.
     const UUID & operator = (const UUID & rhs);
@@ -149,7 +149,7 @@ namespace ACE_Utils
 
   private:
     /// Initialize the UUID
-    void init (void);
+    void init ();
 
     /**
      * Helper method to convert from a string UUID.
@@ -203,14 +203,14 @@ namespace ACE_Utils
     enum {ACE_UUID_CLOCK_SEQ_MASK = 0x3FFF};
 
     /// Default constructor.
-    UUID_Generator(void);
+    UUID_Generator();
 
     /// Destructor.
     ~UUID_Generator();
 
     /// Initialize the UUID generator
     /// @deprecated This method may go away in some future release.
-    void init (void);
+    void init ();
 
     /// Format timestamp, clockseq, and nodeID into an UUID of the
     /// specified version and variant. For generating UUID's with
@@ -227,7 +227,7 @@ namespace ACE_Utils
 
     /// The locking strategy prevents multiple generators from accessing
     /// the UUID_state at the same time. Get the locking strategy.
-    ACE_SYNCH_MUTEX* lock (void);
+    ACE_SYNCH_MUTEX* lock ();
 
     /// Set a new locking strategy and return the old one.
     void lock (ACE_SYNCH_MUTEX* lock, bool release_lock);
diff --git a/ACE/ace/UUID.inl b/ACE/ace/UUID.inl
index cf3a3c150e9..12541cb543a 100644
--- a/ACE/ace/UUID.inl
+++ b/ACE/ace/UUID.inl
@@ -5,19 +5,19 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 namespace ACE_Utils
 {
   ACE_INLINE
-  const UUID_Node::Node_ID & UUID_Node::node_ID (void) const
+  const UUID_Node::Node_ID & UUID_Node::node_ID () const
   {
     return this->node_ID_;
   }
 
   ACE_INLINE
-  UUID_Node::Node_ID & UUID_Node::node_ID (void)
+  UUID_Node::Node_ID & UUID_Node::node_ID ()
   {
     return this->node_ID_;
   }
 
   ACE_INLINE
-  UUID::UUID (void)
+  UUID::UUID ()
   {
     this->init ();
   }
@@ -31,26 +31,26 @@ namespace ACE_Utils
   }
 
   ACE_INLINE
-  UUID::~UUID (void)
+  UUID::~UUID ()
   {
 
   }
 
   ACE_INLINE void
-  UUID::init (void)
+  UUID::init ()
   {
     ACE_OS::memset (&this->uuid_, 0, BINARY_SIZE);
   }
 
   ACE_INLINE unsigned long
-  UUID::hash (void) const
+  UUID::hash () const
   {
     return ACE::hash_pjw (reinterpret_cast <const char *> (&this->uuid_),
                           UUID::BINARY_SIZE);
   }
 
   ACE_INLINE ACE_UINT32
-  UUID::time_low (void) const
+  UUID::time_low () const
   {
     return this->uuid_.time_low_;
   }
@@ -62,7 +62,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE ACE_UINT16
-  UUID::time_mid (void) const
+  UUID::time_mid () const
   {
     return this->uuid_.time_mid_;
   }
@@ -74,7 +74,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE ACE_UINT16
-  UUID::time_hi_and_version (void) const
+  UUID::time_hi_and_version () const
   {
     return this->uuid_.time_hi_and_version_;
   }
@@ -86,7 +86,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE u_char
-  UUID::clock_seq_hi_and_reserved (void) const
+  UUID::clock_seq_hi_and_reserved () const
   {
     return this->uuid_.clock_seq_hi_and_reserved_;
   }
@@ -98,7 +98,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE u_char
-  UUID::clock_seq_low (void) const
+  UUID::clock_seq_low () const
   {
     return this->uuid_.clock_seq_low_;
   }
@@ -110,13 +110,13 @@ namespace ACE_Utils
   }
 
   ACE_INLINE const UUID_Node &
-  UUID::node (void) const
+  UUID::node () const
   {
     return this->uuid_.node_;
   }
 
   ACE_INLINE UUID_Node &
-  UUID::node (void)
+  UUID::node ()
   {
     return this->uuid_.node_;
   }
@@ -130,7 +130,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE ACE_CString*
-  UUID::thr_id (void)
+  UUID::thr_id ()
   {
     return &this->thr_id_;
   }
@@ -142,7 +142,7 @@ namespace ACE_Utils
   }
 
   ACE_INLINE ACE_CString*
-  UUID::pid (void)
+  UUID::pid ()
   {
     return &this->pid_;
   }