1 files changed, 9 insertions, 9 deletions

diff --git a/TAO/tao/Intrusive_Ref_Count_Handle_T.h b/TAO/tao/Intrusive_Ref_Count_Handle_T.h
index 1974d07e2bf..2b293e14b47 100644
--- a/TAO/tao/Intrusive_Ref_Count_Handle_T.h
+++ b/TAO/tao/Intrusive_Ref_Count_Handle_T.h
@@ -65,7 +65,7 @@ class TAO_Intrusive_Ref_Count_Handle
 public:
 
   /// Default Constructor - enters the "nil" state.
-  TAO_Intrusive_Ref_Count_Handle (void);
+  TAO_Intrusive_Ref_Count_Handle ();
 
   /// Ctor - By default, takes ownership of passed-in "copy" of reference
   ///        to T.  But the second argument (bool) can be changed from
@@ -83,7 +83,7 @@ public:
   TAO_Intrusive_Ref_Count_Handle (const TAO_Intrusive_Ref_Count_Handle& b);
 
   /// Destructor
-  ~TAO_Intrusive_Ref_Count_Handle (void);
+  ~TAO_Intrusive_Ref_Count_Handle ();
 
   /// Assignment Operator with T* argument.
   /// Takes ownership of passed-in "copy" of reference to T.
@@ -99,21 +99,21 @@ public:
 
   /// Returns true if underlying pointer is NULL (0).
   /// Returns false otherwise.
-  bool is_nil (void) const;
+  bool is_nil () const;
 
   /// Used to pass the underlying pointer as an "IN" argument to a method.
-  T* in (void) const;
+  T* in () const;
 
   /// Used to pass the underlying pointer as an "IN/OUT" argument to a method.
-  T*& inout (void);
+  T*& inout ();
 
   /// Used to pass the underlying pointer as an "OUT" argument to a method.
-  T*& out (void);
+  T*& out ();
 
   /// Used to take-away the underlying pointer from this smart pointer object.
   /// Caller becomes responsibe for the returned "copy" to the reference.
   /// Always leaves the smart pointer in the "nil" state upon return.
-  T* _retn (void);
+  T* _retn ();
 
   /// Equality operator allows the refcounted object to be used generically
   /// as a contained object
@@ -124,14 +124,14 @@ private:
   /// Claim a "copy" of the reference-counted object by adding
   /// one to its reference counter.  Do nothing if this smart pointer
   /// object is currently in the "nil" state.
-  void claim (void);
+  void claim ();
 
   /// Drop our "copy" of the reference-counted object by removing
   /// one from its reference counter.  Do nothing if this smart pointer
   /// object is currently in the "nil" state.
   /// Note that this method will always leave this smart pointer
   /// in the "nil" state upon its return.
-  void drop (void);
+  void drop ();
 
   /// The underlying pointer to the (intrusively) reference-counted object.
   /// Set to 0 when this smart pointer is in the "nil" state.  Otherwise,