diff options
Diffstat (limited to 'ACE/ace')
209 files changed, 2210 insertions, 2210 deletions
diff --git a/ACE/ace/ACE.h b/ACE/ace/ACE.h index d10dc6710d1..b705e092d95 100644 --- a/ACE/ace/ACE.h +++ b/ACE/ace/ACE.h @@ -55,31 +55,31 @@ namespace ACE { // = ACE version information. /// e.g., the "6" in ACE 6.3.4 - extern ACE_Export u_int major_version (void); + extern ACE_Export u_int major_version (); /// e.g., the "3" in ACE 6.3.4 - extern ACE_Export u_int minor_version (void); + extern ACE_Export u_int minor_version (); /// e.g., the "4" in ACE 6.3.4 /// Returns 0 for "stable" (non-micro) releases. - extern ACE_Export u_int micro_version (void); + extern ACE_Export u_int micro_version (); /// e.g., the "4" in ACE 6.3.4 /// Returns 0 for "stable" (non-micro) releases. - extern ACE_Export u_int beta_version (void); + extern ACE_Export u_int beta_version (); // = C++ compiler version information. /// E.g., the "SunPro C++" in SunPro C++ 4.32.0 - extern ACE_Export const ACE_TCHAR * compiler_name (void); + extern ACE_Export const ACE_TCHAR * compiler_name (); /// E.g., the "4" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_major_version (void); + extern ACE_Export u_int compiler_major_version (); /// E.g., the "32" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_minor_version (void); + extern ACE_Export u_int compiler_minor_version (); /// E.g., the "0" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_beta_version (void); + extern ACE_Export u_int compiler_beta_version (); /// Check if error indicates the process being out of handles (file /// descriptors). @@ -388,7 +388,7 @@ namespace ACE * this process. This maximum may be extended using * @c ACE::set_handle_limit. */ - extern ACE_Export int max_handles (void); + extern ACE_Export int max_handles (); // = String functions /** @@ -680,7 +680,7 @@ namespace ACE ACE_NAMESPACE_INLINE_FUNCTION u_char hex2byte (ACE_TCHAR c); // = Set/get the debug level. - extern ACE_Export bool debug (void); + extern ACE_Export bool debug (); extern ACE_Export void debug (bool onoff); /// Wrapper facade for @c select that uses @c ACE_Handle_Sets. diff --git a/ACE/ace/Active_Map_Manager.h b/ACE/ace/Active_Map_Manager.h index 3bf29130bf6..109d690dadb 100644 --- a/ACE/ace/Active_Map_Manager.h +++ b/ACE/ace/Active_Map_Manager.h @@ -36,7 +36,7 @@ class ACE_Export ACE_Active_Map_Manager_Key { public: /// Default constructor. - ACE_Active_Map_Manager_Key (void); + ACE_Active_Map_Manager_Key (); /** * Constructor given the @a slot_index and @a slot_generation number. @@ -47,19 +47,19 @@ public: ACE_UINT32 slot_generation); /// Get the slot_index. - ACE_UINT32 slot_index (void) const; + ACE_UINT32 slot_index () const; /// Set the slot_index. void slot_index (ACE_UINT32 i); /// Get the slot_generation number. - ACE_UINT32 slot_generation (void) const; + ACE_UINT32 slot_generation () const; /// Set the slot_generation number. void slot_generation (ACE_UINT32 g); /// Size required to store information about active key. - static size_t size (void); + static size_t size (); /// Recover state of active key from @a data. User must make sure /// that @a data encoded using the encode() method. @@ -77,7 +77,7 @@ public: // friends, they are not. /// Increment the slot_generation number. - void increment_slot_generation_count (void); + void increment_slot_generation_count (); private: /** diff --git a/ACE/ace/Active_Map_Manager.inl b/ACE/ace/Active_Map_Manager.inl index 2fc8c13e5d9..6abb8c62079 100644 --- a/ACE/ace/Active_Map_Manager.inl +++ b/ACE/ace/Active_Map_Manager.inl @@ -4,7 +4,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key (void) +ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key () { // If you change ~0, please change ACE_Map_Manager::free_list_id() // accordingly. @@ -21,13 +21,13 @@ ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key (ACE_UINT32 slot_index, } ACE_INLINE ACE_UINT32 -ACE_Active_Map_Manager_Key::slot_index (void) const +ACE_Active_Map_Manager_Key::slot_index () const { return this->key_data_.slot_index_; } ACE_INLINE ACE_UINT32 -ACE_Active_Map_Manager_Key::slot_generation (void) const +ACE_Active_Map_Manager_Key::slot_generation () const { return this->key_data_.slot_generation_; } @@ -59,14 +59,14 @@ ACE_Active_Map_Manager_Key::slot_generation (ACE_UINT32 g) } ACE_INLINE void -ACE_Active_Map_Manager_Key::increment_slot_generation_count (void) +ACE_Active_Map_Manager_Key::increment_slot_generation_count () { ++this->key_data_.slot_generation_; } /* static */ ACE_INLINE size_t -ACE_Active_Map_Manager_Key::size (void) +ACE_Active_Map_Manager_Key::size () { return sizeof (ACE_UINT32) + sizeof (ACE_UINT32); } diff --git a/ACE/ace/Active_Map_Manager_T.h b/ACE/ace/Active_Map_Manager_T.h index 472ea71911b..ee4e7783e8d 100644 --- a/ACE/ace/Active_Map_Manager_T.h +++ b/ACE/ace/Active_Map_Manager_T.h @@ -58,7 +58,7 @@ public: /// Close down a Active_Map_Manager and release dynamically /// allocated resources. - ~ACE_Active_Map_Manager (void); + ~ACE_Active_Map_Manager (); /// Initialize a Active_Map_Manager with size @a length. int open (size_t length = ACE_DEFAULT_MAP_SIZE, @@ -66,7 +66,7 @@ public: /// Close down a Active_Map_Manager and release dynamically /// allocated resources. - int close (void); + int close (); /// Add @a value to the map, and the corresponding key produced by the /// Active_Map_Manager is returned through @a key. @@ -153,26 +153,26 @@ public: T *&internal_value); /// Return the current size of the map. - size_t current_size (void) const; + size_t current_size () const; /// Return the total size of the map. - size_t total_size (void) const; + size_t total_size () const; /// Returns a key that cannot be found in the map. - static const ACE_Active_Map_Manager_Key npos (void); + static const ACE_Active_Map_Manager_Key npos (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iterator factory functions. /// Return forward iterator. - ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> begin (void); - ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> end (void); + ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> begin (); + ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> end (); /// Return reverse iterator. - ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rbegin (void); - ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rend (void); + ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rbegin (); + ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> rend (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; diff --git a/ACE/ace/Active_Map_Manager_T.inl b/ACE/ace/Active_Map_Manager_T.inl index c8a6caf9b52..5e7cec0d0ff 100644 --- a/ACE/ace/Active_Map_Manager_T.inl +++ b/ACE/ace/Active_Map_Manager_T.inl @@ -237,7 +237,7 @@ ACE_Active_Map_Manager<T>::ACE_Active_Map_Manager (size_t size, } template <class T> ACE_INLINE -ACE_Active_Map_Manager<T>::~ACE_Active_Map_Manager (void) +ACE_Active_Map_Manager<T>::~ACE_Active_Map_Manager () { } @@ -249,32 +249,32 @@ ACE_Active_Map_Manager<T>::open (size_t length, } template <class T> ACE_INLINE int -ACE_Active_Map_Manager<T>::close (void) +ACE_Active_Map_Manager<T>::close () { return ACE_AMM_BASE::close (); } template <class T> ACE_INLINE size_t -ACE_Active_Map_Manager<T>::current_size (void) const +ACE_Active_Map_Manager<T>::current_size () const { return ACE_AMM_BASE::current_size (); } template <class T> ACE_INLINE size_t -ACE_Active_Map_Manager<T>::total_size (void) const +ACE_Active_Map_Manager<T>::total_size () const { return ACE_AMM_BASE::total_size (); } /* static */ template <class T> ACE_INLINE const ACE_Active_Map_Manager_Key -ACE_Active_Map_Manager<T>::npos (void) +ACE_Active_Map_Manager<T>::npos () { return ACE_Active_Map_Manager_Key (~0, ~0); } template <class T> ACE_INLINE void -ACE_Active_Map_Manager<T>::dump (void) const +ACE_Active_Map_Manager<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_AMM_BASE::dump (); @@ -282,25 +282,25 @@ ACE_Active_Map_Manager<T>::dump (void) const } template <class T> ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> -ACE_Active_Map_Manager<T>::begin (void) +ACE_Active_Map_Manager<T>::begin () { return ACE_AMM_BASE::begin (); } template <class T> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> -ACE_Active_Map_Manager<T>::end (void) +ACE_Active_Map_Manager<T>::end () { return ACE_AMM_BASE::end (); } template <class T> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> -ACE_Active_Map_Manager<T>::rbegin (void) +ACE_Active_Map_Manager<T>::rbegin () { return ACE_AMM_BASE::rbegin (); } template <class T> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, T, ACE_Null_Mutex> -ACE_Active_Map_Manager<T>::rend (void) +ACE_Active_Map_Manager<T>::rend () { return ACE_AMM_BASE::rend (); } diff --git a/ACE/ace/Array_Base.h b/ACE/ace/Array_Base.h index 15ffe77c361..d5ed71e47df 100644 --- a/ACE/ace/Array_Base.h +++ b/ACE/ace/Array_Base.h @@ -85,7 +85,7 @@ public: void operator= (ACE_Array_Base<T> const & s); /// Clean up the array (e.g., delete dynamically allocated memory). - ~ACE_Array_Base (void); + ~ACE_Array_Base (); // = Set/get methods. @@ -110,7 +110,7 @@ public: int get (T & item, size_type slot) const; /// Returns the <cur_size_> of the array. - size_type size (void) const; + size_type size () const; /** * Changes the size of the array to match @a new_size. @@ -120,7 +120,7 @@ public: int size (size_type new_size); /// Returns the <max_size_> of the array. - size_type max_size (void) const; + size_type max_size () const; /** * Changes the size of the array to match @a new_size. @@ -136,10 +136,10 @@ public: * Forward iterator accessors. */ //@{ - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; + iterator begin (); + iterator end (); + const_iterator begin () const; + const_iterator end () const; //@} /** @@ -148,10 +148,10 @@ public: * Reverse iterator accessors. */ //@{ - reverse_iterator rbegin (void); - reverse_iterator rend (void); - const_reverse_iterator rbegin (void) const; - const_reverse_iterator rend (void) const; + reverse_iterator rbegin (); + reverse_iterator rend (); + const_reverse_iterator rbegin () const; + const_reverse_iterator rend () const; //@} /// Swap the contents of this array with the given @a array in @@ -212,13 +212,13 @@ public: /// Move forward by one element in the Array. Returns 0 when all the /// items in the Array have been seen, else 1. - int advance (void); + int advance (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// 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/Array_Base.inl b/ACE/ace/Array_Base.inl index ccd367f2d98..5a5cef338ff 100644 --- a/ACE/ace/Array_Base.inl +++ b/ACE/ace/Array_Base.inl @@ -3,7 +3,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL // Clean up the array (e.g., delete dynamically allocated memory). template <class T> ACE_INLINE -ACE_Array_Base<T>::~ACE_Array_Base (void) +ACE_Array_Base<T>::~ACE_Array_Base () { ACE_DES_ARRAY_FREE (this->array_, this->max_size_, @@ -13,68 +13,68 @@ ACE_Array_Base<T>::~ACE_Array_Base (void) template <class T> ACE_INLINE typename ACE_Array_Base<T>::iterator -ACE_Array_Base<T>::begin (void) +ACE_Array_Base<T>::begin () { return this->array_; } template <class T> ACE_INLINE typename ACE_Array_Base<T>::iterator -ACE_Array_Base<T>::end (void) +ACE_Array_Base<T>::end () { return this->array_ + this->cur_size_; } template <class T> ACE_INLINE typename ACE_Array_Base<T>::const_iterator -ACE_Array_Base<T>::begin (void) const +ACE_Array_Base<T>::begin () const { return this->array_; } template <class T> ACE_INLINE typename ACE_Array_Base<T>::const_iterator -ACE_Array_Base<T>::end (void) const +ACE_Array_Base<T>::end () const { return this->array_ + this->cur_size_; } template <class T> ACE_INLINE typename ACE_Array_Base<T>::reverse_iterator -ACE_Array_Base<T>::rbegin (void) +ACE_Array_Base<T>::rbegin () { return reverse_iterator (this->end ()); } template <class T> ACE_INLINE typename ACE_Array_Base<T>::reverse_iterator -ACE_Array_Base<T>::rend (void) +ACE_Array_Base<T>::rend () { return reverse_iterator (this->begin ()); } template <class T> ACE_INLINE typename ACE_Array_Base<T>::const_reverse_iterator -ACE_Array_Base<T>::rbegin (void) const +ACE_Array_Base<T>::rbegin () const { return const_reverse_iterator (this->end ()); } template <class T> ACE_INLINE typename ACE_Array_Base<T>::const_reverse_iterator -ACE_Array_Base<T>::rend (void) const +ACE_Array_Base<T>::rend () const { return const_reverse_iterator (this->begin ()); } template <class T> ACE_INLINE typename ACE_Array_Base<T>::size_type -ACE_Array_Base<T>::size (void) const +ACE_Array_Base<T>::size () const { return this->cur_size_; } template <class T> ACE_INLINE typename ACE_Array_Base<T>::size_type -ACE_Array_Base<T>::max_size (void) const +ACE_Array_Base<T>::max_size () const { return this->max_size_; } @@ -100,7 +100,7 @@ ACE_Array_Base<T>::operator[] (typename ACE_Array_Base<T>::size_type index) cons // **************************************************************** template <class T> ACE_INLINE void -ACE_Array_Iterator<T>::dump (void) const +ACE_Array_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Array_Iterator<T>::dump"); @@ -116,7 +116,7 @@ ACE_Array_Iterator<T>::ACE_Array_Iterator (ACE_Array_Base<T> &a) } template <class T> ACE_INLINE int -ACE_Array_Iterator<T>::advance (void) +ACE_Array_Iterator<T>::advance () { // ACE_TRACE ("ACE_Array_Iterator<T>::advance"); @@ -133,7 +133,7 @@ ACE_Array_Iterator<T>::advance (void) } template <class T> ACE_INLINE int -ACE_Array_Iterator<T>::done (void) const +ACE_Array_Iterator<T>::done () const { ACE_TRACE ("ACE_Array_Iterator<T>::done"); diff --git a/ACE/ace/Array_Map.cpp b/ACE/ace/Array_Map.cpp index 4917c51e42f..9a62b7275bf 100644 --- a/ACE/ace/Array_Map.cpp +++ b/ACE/ace/Array_Map.cpp @@ -41,7 +41,7 @@ ACE_Array_Map<Key, Value, EqualTo, Alloc>::ACE_Array_Map ( } template<typename Key, typename Value, class EqualTo, class Alloc> -ACE_Array_Map<Key, Value, EqualTo, Alloc>::~ACE_Array_Map (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::~ACE_Array_Map () { for (size_t idx = 0; idx != capacity_; ++idx) { @@ -162,7 +162,7 @@ ACE_Array_Map<Key, Value, EqualTo, Alloc>::erase ( template<typename Key, typename Value, class EqualTo, class Alloc> void -ACE_Array_Map<Key, Value, EqualTo, Alloc>::clear (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::clear () { this->size_ = 0; // No need to deallocate array nor destroy elements. } diff --git a/ACE/ace/Array_Map.h b/ACE/ace/Array_Map.h index 5fd040069ee..4feefe97066 100644 --- a/ACE/ace/Array_Map.h +++ b/ACE/ace/Array_Map.h @@ -125,7 +125,7 @@ public: ACE_Array_Map & operator= (ACE_Array_Map const & map); /// Destructor. - ~ACE_Array_Map (void); + ~ACE_Array_Map (); /** * @name Forward Iterator Accessors @@ -133,10 +133,10 @@ public: * Forward iterator accessors. */ //@{ - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; + iterator begin (); + iterator end (); + const_iterator begin () const; + const_iterator end () const; //@} /** @@ -145,30 +145,30 @@ public: * Reverse iterator accessors. */ //@{ - reverse_iterator rbegin (void); - reverse_iterator rend (void); - const_reverse_iterator rbegin (void) const; - const_reverse_iterator rend (void) const; + reverse_iterator rbegin (); + reverse_iterator rend (); + const_reverse_iterator rbegin () const; + const_reverse_iterator rend () const; //@} /// Return current size of map. /** * @return The number of elements in the map. */ - size_type size (void) const; + size_type size () const; /// Maximum number of elements the map can hold. - size_type max_size (void) const; + size_type max_size () const; /// Return @c true if the map is empty, else @c false. - bool is_empty (void) const; // ACE style + bool is_empty () const; // ACE style /** * Return @c true if the map is empty, else @c false. We recommend * using @c is_empty() instead since it's more consistent with the * ACE container naming conventions. */ - bool empty (void) const; // STL style + bool empty () const; // STL style /// Swap the contents of this map with the given @a map in an /// exception-safe manner. @@ -208,7 +208,7 @@ public: /** * @note This a constant time (O(1)) operation. */ - void clear (void); + void clear (); /** * @name Search Operations diff --git a/ACE/ace/Array_Map.inl b/ACE/ace/Array_Map.inl index 32e7848c02d..d9c8978332f 100644 --- a/ACE/ace/Array_Map.inl +++ b/ACE/ace/Array_Map.inl @@ -26,77 +26,77 @@ ACE_Array_Map<Key, Value, EqualTo, Alloc>::operator= ( template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::begin (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::begin () { return this->nodes_; } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::end (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::end () { return this->nodes_ + this->size_; } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::const_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::begin (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::begin () const { return this->nodes_; } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::const_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::end (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::end () const { return this->nodes_ + this->size_; } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::reverse_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::rbegin (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::rbegin () { return reverse_iterator (this->end ()); } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::reverse_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::rend (void) +ACE_Array_Map<Key, Value, EqualTo, Alloc>::rend () { return reverse_iterator (this->begin ()); } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::const_reverse_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::rbegin (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::rbegin () const { return const_reverse_iterator (this->end ()); } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::const_reverse_iterator -ACE_Array_Map<Key, Value, EqualTo, Alloc>::rend (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::rend () const { return const_reverse_iterator (this->begin ()); } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::size_type -ACE_Array_Map<Key, Value, EqualTo, Alloc>::size (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::size () const { return this->size_; } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE typename ACE_Array_Map<Key, Value, EqualTo, Alloc>::size_type -ACE_Array_Map<Key, Value, EqualTo, Alloc>::max_size (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::max_size () const { return size_type (-1) / sizeof (value_type); } template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE bool -ACE_Array_Map<Key, Value, EqualTo, Alloc>::is_empty (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::is_empty () const { return this->size_ == 0; } @@ -105,7 +105,7 @@ ACE_Array_Map<Key, Value, EqualTo, Alloc>::is_empty (void) const template<typename Key, typename Value, class EqualTo, class Alloc> ACE_INLINE bool -ACE_Array_Map<Key, Value, EqualTo, Alloc>::empty (void) const +ACE_Array_Map<Key, Value, EqualTo, Alloc>::empty () const { return this->is_empty (); } diff --git a/ACE/ace/Atomic_Op.h b/ACE/ace/Atomic_Op.h index b9b179c007a..4f259c319e3 100644 --- a/ACE/ace/Atomic_Op.h +++ b/ACE/ace/Atomic_Op.h @@ -265,7 +265,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, int> : public ACE_Atomic_Op_GCC<int> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (int c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, int> &c); ACE_Atomic_Op<ACE_Thread_Mutex, int> &operator= (int rhs); @@ -276,7 +276,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int> : public ACE_Atomic_Op_GCC<unsigned int> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (unsigned int c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned> &c); ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int> &operator= (unsigned int rhs); @@ -289,7 +289,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, long> : public ACE_Atomic_Op_GCC<long> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (long c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long> &c); ACE_Atomic_Op<ACE_Thread_Mutex, long> &operator= (long rhs); @@ -300,7 +300,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> : public ACE_Atomic_Op_GCC<unsigned long> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (unsigned long c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &c); ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &operator= (unsigned long rhs); @@ -313,7 +313,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, long long> : public ACE_Atomic_Op_GCC<long long> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (long long c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long long> &c); ACE_Atomic_Op<ACE_Thread_Mutex, long long> &operator= (long long rhs); @@ -324,7 +324,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long> : public ACE_Atomic_Op_GCC<unsigned long long> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (unsigned long long c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long> &c); ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long> &operator= (unsigned long long rhs); @@ -337,7 +337,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, short> : public ACE_Atomic_Op_GCC<short> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (short c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, short> &c); ACE_Atomic_Op<ACE_Thread_Mutex, short> &operator= (short rhs); @@ -348,7 +348,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short> : public ACE_Atomic_Op_GCC<unsigned short> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (unsigned short c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short> &c); ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short> &operator= (unsigned short rhs); @@ -361,7 +361,7 @@ class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, bool> : public ACE_Atomic_Op_GCC<bool> { public: - ACE_Atomic_Op (void); + ACE_Atomic_Op (); ACE_Atomic_Op (bool c); ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, bool> &c); ACE_Atomic_Op<ACE_Thread_Mutex, bool> &operator= (bool rhs); diff --git a/ACE/ace/Atomic_Op.inl b/ACE/ace/Atomic_Op.inl index 2f9ec57bac2..318339d0363 100644 --- a/ACE/ace/Atomic_Op.inl +++ b/ACE/ace/Atomic_Op.inl @@ -419,7 +419,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::value_i (void) #if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<int> () { } @@ -446,7 +446,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, int>::operator= (int rhs) ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<unsigned int>() { } @@ -472,7 +472,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::operator= (unsigned int rhs) } ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<long>() { } @@ -498,7 +498,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs) } ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<unsigned long> () { } @@ -526,7 +526,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (unsigned long rhs) // The long long intrinsics are not available on PPC #if !defined (__powerpc__) ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, long long>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, long long>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<long long>() { } @@ -552,7 +552,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long long>::operator= (long long rhs) } ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<unsigned long long> () { } @@ -580,7 +580,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::operator= (unsigned long lo #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_2) ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<short>() { } @@ -606,7 +606,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, short>::operator= (short rhs) } ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<unsigned short> () { } @@ -634,7 +634,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::operator= (unsigned short rhs) #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_1) ACE_INLINE -ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (void) : +ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op () : ACE_Atomic_Op_GCC<bool> () { } diff --git a/ACE/ace/Atomic_Op_GCC_T.cpp b/ACE/ace/Atomic_Op_GCC_T.cpp index 3e7e7cada05..8e263daa877 100644 --- a/ACE/ace/Atomic_Op_GCC_T.cpp +++ b/ACE/ace/Atomic_Op_GCC_T.cpp @@ -10,7 +10,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <typename T> void -ACE_Atomic_Op_GCC<T>::dump (void) const +ACE_Atomic_Op_GCC<T>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); diff --git a/ACE/ace/Atomic_Op_GCC_T.h b/ACE/ace/Atomic_Op_GCC_T.h index 38485af3bac..13d363163ea 100644 --- a/ACE/ace/Atomic_Op_GCC_T.h +++ b/ACE/ace/Atomic_Op_GCC_T.h @@ -37,7 +37,7 @@ class ACE_Export ACE_Atomic_Op_GCC { public: /// Atomically pre-increment @c value_. - T operator++ (void); + T operator++ (); /// Atomically post-increment @c value_. T operator++ (int); @@ -46,7 +46,7 @@ public: T operator+= (T rhs); /// Atomically pre-decrement @c value_. - T operator-- (void); + T operator-- (); /// Atomically post-decrement @c value_. T operator-- (int); @@ -76,13 +76,13 @@ public: T exchange (T newval); /// Explicitly return @c value_. - T value (void) const; + T value () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Explicitly return @c value_ (by reference). - volatile T &value_i (void); + volatile T &value_i (); // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. @@ -95,7 +95,7 @@ protected: ACE_Atomic_Op_GCC<T> &operator= (const ACE_Atomic_Op_GCC<T> &rhs); /// Initialize @c value_ to 0. - ACE_Atomic_Op_GCC (void); + ACE_Atomic_Op_GCC (); /// Initialize @c value_ to c. ACE_Atomic_Op_GCC (T c); @@ -107,7 +107,7 @@ private: // This function cannot be supported by this template specialization. // If you need access to an underlying lock, use the ACE_Atomic_Op_Ex // template instead. - ACE_Thread_Mutex &mutex (void); + ACE_Thread_Mutex &mutex (); private: /// Current object decorated by the atomic op. diff --git a/ACE/ace/Atomic_Op_GCC_T.inl b/ACE/ace/Atomic_Op_GCC_T.inl index 90f7c4839c2..b102d422395 100644 --- a/ACE/ace/Atomic_Op_GCC_T.inl +++ b/ACE/ace/Atomic_Op_GCC_T.inl @@ -5,7 +5,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <typename T> ACE_INLINE -ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC (void) +ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC () : value_ (0) { } @@ -27,7 +27,7 @@ ACE_Atomic_Op_GCC<T>::ACE_Atomic_Op_GCC ( template <typename T> ACE_INLINE T -ACE_Atomic_Op_GCC<T>::operator++ (void) +ACE_Atomic_Op_GCC<T>::operator++ () { return __sync_add_and_fetch (&this->value_, 1); } @@ -41,7 +41,7 @@ ACE_Atomic_Op_GCC<T>::operator++ (int) template <typename T> ACE_INLINE T -ACE_Atomic_Op_GCC<T>::operator-- (void) +ACE_Atomic_Op_GCC<T>::operator-- () { return __sync_sub_and_fetch (&this->value_, 1); } @@ -135,14 +135,14 @@ ACE_Atomic_Op_GCC<T>::exchange (T newval) template <typename T> ACE_INLINE T -ACE_Atomic_Op_GCC<T>::value (void) const +ACE_Atomic_Op_GCC<T>::value () const { return this->value_; } template <typename T> ACE_INLINE volatile T & -ACE_Atomic_Op_GCC<T>::value_i (void) +ACE_Atomic_Op_GCC<T>::value_i () { return this->value_; } diff --git a/ACE/ace/Atomic_Op_T.cpp b/ACE/ace/Atomic_Op_T.cpp index d925d6e4623..f0a53fa4778 100644 --- a/ACE/ace/Atomic_Op_T.cpp +++ b/ACE/ace/Atomic_Op_T.cpp @@ -26,7 +26,7 @@ ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Atomic_Op) // ************************************************* template <class ACE_LOCK, class TYPE> ACE_LOCK & -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::mutex (void) +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::mutex () { // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::mutex"); return this->mutex_; @@ -34,7 +34,7 @@ ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::mutex (void) template <class ACE_LOCK, class TYPE> void -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::dump (void) const +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::dump"); @@ -65,7 +65,7 @@ ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::ACE_Atomic_Op_Ex ( // **************************************************************** template <class ACE_LOCK, class TYPE> -ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op (void) +ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op () : impl_ (this->own_mutex_) { // ACE_TRACE ("ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op"); diff --git a/ACE/ace/Atomic_Op_T.h b/ACE/ace/Atomic_Op_T.h index c3d936c1fe9..599ae7075b6 100644 --- a/ACE/ace/Atomic_Op_T.h +++ b/ACE/ace/Atomic_Op_T.h @@ -155,7 +155,7 @@ public: // = Accessors. /// Atomically pre-increment @c value_. - TYPE operator++ (void); + TYPE operator++ (); /// Atomically post-increment @c value_. TYPE operator++ (int); @@ -164,7 +164,7 @@ public: TYPE operator+= (arg_type rhs); /// Atomically pre-decrement @c value_. - TYPE operator-- (void); + TYPE operator-- (); /// Atomically post-decrement @c value_. TYPE operator-- (int); @@ -201,10 +201,10 @@ public: TYPE exchange (TYPE newval); /// Explicitly return @c value_. - TYPE value (void) const; + TYPE value () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -220,7 +220,7 @@ public: * * @note The right name would be lock_, but HP/C++ will choke on that! */ - ACE_LOCK & mutex (void); + ACE_LOCK & mutex (); /** * Explicitly return @c value_ (by reference). This gives the user @@ -228,7 +228,7 @@ public: * will usually be used in conjunction with explicit access to the * lock. Use with care ;-) */ - TYPE & value_i (void); + TYPE & value_i (); private: /// Type of synchronization mechanism. @@ -259,7 +259,7 @@ public: typedef typename ACE_Type_Traits<TYPE>::parameter_type arg_type; /// Initialize @c value_ to 0. - ACE_Atomic_Op (void); + ACE_Atomic_Op (); /// Initialize @c value_ to c. ACE_Atomic_Op (arg_type c); @@ -275,7 +275,7 @@ public: ACE_Atomic_Op<ACE_LOCK, TYPE> const & rhs); /// Atomically pre-increment @c value_. - TYPE operator++ (void); + TYPE operator++ (); /// Atomically post-increment @c value_. TYPE operator++ (int); @@ -284,7 +284,7 @@ public: TYPE operator+= (arg_type rhs); /// Atomically pre-decrement @c value_. - TYPE operator-- (void); + TYPE operator-- (); /// Atomically post-decrement @c value_. TYPE operator-- (int); @@ -314,10 +314,10 @@ public: TYPE exchange (TYPE newval); /// Explicitly return @c value_. - TYPE value (void) const; + TYPE value () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -328,7 +328,7 @@ public: * will usually be used in conjunction with explicit access to the * lock. Use with care ;-) */ - TYPE & value_i (void); + TYPE & value_i (); private: /// Type of synchronization mechanism. diff --git a/ACE/ace/Atomic_Op_T.inl b/ACE/ace/Atomic_Op_T.inl index 1b1eb988f94..641f6bd36c5 100644 --- a/ACE/ace/Atomic_Op_T.inl +++ b/ACE/ace/Atomic_Op_T.inl @@ -11,7 +11,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ (void) +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++ () { // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator++"); ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); @@ -30,7 +30,7 @@ ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator+= ( template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- (void) +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator-- () { // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator--"); ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); @@ -161,7 +161,7 @@ ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::exchange (TYPE newval) template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value (void) const +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value () const { // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value"); ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); @@ -170,7 +170,7 @@ ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value (void) const template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE & -ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value_i (void) +ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value_i () { // Explicitly return <value_> (by reference). This gives the user // full, unrestricted access to the underlying value. This method @@ -223,7 +223,7 @@ ACE_Atomic_Op<ACE_LOCK, TYPE>::operator= ( template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ (void) +ACE_Atomic_Op<ACE_LOCK, TYPE>::operator++ () { return ++this->impl_; } @@ -245,7 +245,7 @@ ACE_Atomic_Op<ACE_LOCK, TYPE>::operator+= ( template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- (void) +ACE_Atomic_Op<ACE_LOCK, TYPE>::operator-- () { return --this->impl_; } @@ -322,14 +322,14 @@ ACE_Atomic_Op<ACE_LOCK, TYPE>::exchange (TYPE newval) template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE -ACE_Atomic_Op<ACE_LOCK, TYPE>::value (void) const +ACE_Atomic_Op<ACE_LOCK, TYPE>::value () const { return this->impl_.value (); } template <class ACE_LOCK, class TYPE> ACE_INLINE void -ACE_Atomic_Op<ACE_LOCK, TYPE>::dump (void) const +ACE_Atomic_Op<ACE_LOCK, TYPE>::dump () const { #if defined (ACE_HAS_DUMP) this->impl_.dump (); @@ -338,7 +338,7 @@ ACE_Atomic_Op<ACE_LOCK, TYPE>::dump (void) const } template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE & -ACE_Atomic_Op<ACE_LOCK, TYPE>::value_i (void) +ACE_Atomic_Op<ACE_LOCK, TYPE>::value_i () { return this->impl_.value_i (); } diff --git a/ACE/ace/Auto_Event.cpp b/ACE/ace/Auto_Event.cpp index c95c0e855c3..52024445aa6 100644 --- a/ACE/ace/Auto_Event.cpp +++ b/ACE/ace/Auto_Event.cpp @@ -44,7 +44,7 @@ ACE_Auto_Event_T<TIME_POLICY>::ACE_Auto_Event_T ( template <class TIME_POLICY> void -ACE_Auto_Event_T<TIME_POLICY>::dump (void) const +ACE_Auto_Event_T<TIME_POLICY>::dump () const { #if defined (ACE_HAS_DUMP) ACE_Event_T<TIME_POLICY>::dump (); diff --git a/ACE/ace/Auto_Event.h b/ACE/ace/Auto_Event.h index f01882c62c1..d57fd71e718 100644 --- a/ACE/ace/Auto_Event.h +++ b/ACE/ace/Auto_Event.h @@ -53,10 +53,10 @@ public: #endif /* ACE_HAS_WCHAR */ /// Default dtor. - virtual ~ACE_Auto_Event_T (void); + virtual ~ACE_Auto_Event_T (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks ACE_ALLOC_HOOK_DECLARE; @@ -87,7 +87,7 @@ public: #endif /* ACE_HAS_WCHAR */ /// Default dtor. - virtual ~ACE_Auto_Event (void) + virtual ~ACE_Auto_Event () { } }; diff --git a/ACE/ace/Auto_Event.inl b/ACE/ace/Auto_Event.inl index 919c048d3ce..a8add6194f6 100644 --- a/ACE/ace/Auto_Event.inl +++ b/ACE/ace/Auto_Event.inl @@ -3,7 +3,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class TIME_POLICY> ACE_INLINE -ACE_Auto_Event_T<TIME_POLICY>::~ACE_Auto_Event_T (void) +ACE_Auto_Event_T<TIME_POLICY>::~ACE_Auto_Event_T () { } diff --git a/ACE/ace/Auto_Ptr.h b/ACE/ace/Auto_Ptr.h index 9f8af214a31..21365a540d8 100644 --- a/ACE/ace/Auto_Ptr.h +++ b/ACE/ace/Auto_Ptr.h @@ -48,16 +48,16 @@ public: ACE_Auto_Basic_Ptr (ACE_Auto_Basic_Ptr<X> & ap); ACE_Auto_Basic_Ptr<X> &operator= (ACE_Auto_Basic_Ptr<X> & rhs); - ~ACE_Auto_Basic_Ptr (void); + ~ACE_Auto_Basic_Ptr (); // = Accessor methods. X &operator *() const; - X *get (void) const; - X *release (void); + X *get () const; + X *release (); void reset (X * p = 0); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -132,17 +132,17 @@ public: ACE_Auto_Basic_Array_Ptr (ACE_Auto_Basic_Array_Ptr<X> & ap); ACE_Auto_Basic_Array_Ptr<X> &operator= (ACE_Auto_Basic_Array_Ptr<X> & rhs); - ~ACE_Auto_Basic_Array_Ptr (void); + ~ACE_Auto_Basic_Array_Ptr (); // = Accessor methods. X & operator* () const; X & operator[] (int i) const; - X * get (void) const; - X * release (void); + X * get () const; + X * release (); void reset (X * p = 0); /// 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/Auto_Ptr.inl b/ACE/ace/Auto_Ptr.inl index 1cc93536e42..06b035f7f98 100644 --- a/ACE/ace/Auto_Ptr.inl +++ b/ACE/ace/Auto_Ptr.inl @@ -8,7 +8,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class X> ACE_INLINE void -ACE_Auto_Basic_Ptr<X>::dump (void) const +ACE_Auto_Basic_Ptr<X>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::dump"); @@ -16,7 +16,7 @@ ACE_Auto_Basic_Ptr<X>::dump (void) const } template<class X> ACE_INLINE void -ACE_Auto_Basic_Array_Ptr<X>::dump (void) const +ACE_Auto_Basic_Array_Ptr<X>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::dump"); @@ -31,14 +31,14 @@ ACE_Auto_Basic_Ptr<X>::ACE_Auto_Basic_Ptr (ACE_Auto_Basic_Ptr<X> &rhs) } template<class X> ACE_INLINE X * -ACE_Auto_Basic_Ptr<X>::get (void) const +ACE_Auto_Basic_Ptr<X>::get () const { ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::get"); return this->p_; } template<class X> ACE_INLINE X * -ACE_Auto_Basic_Ptr<X>::release (void) +ACE_Auto_Basic_Ptr<X>::release () { ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::release"); X *old = this->p_; @@ -67,7 +67,7 @@ ACE_Auto_Basic_Ptr<X>::operator= (ACE_Auto_Basic_Ptr<X> &rhs) } template<class X> ACE_INLINE -ACE_Auto_Basic_Ptr<X>::~ACE_Auto_Basic_Ptr (void) +ACE_Auto_Basic_Ptr<X>::~ACE_Auto_Basic_Ptr () { ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::~ACE_Auto_Basic_Ptr"); delete this->get (); @@ -101,14 +101,14 @@ ACE_Auto_Ptr<X>::operator-> () const } template<class X> ACE_INLINE X * -ACE_Auto_Basic_Array_Ptr<X>::get (void) const +ACE_Auto_Basic_Array_Ptr<X>::get () const { ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::get"); return this->p_; } template<class X> ACE_INLINE X * -ACE_Auto_Basic_Array_Ptr<X>::release (void) +ACE_Auto_Basic_Array_Ptr<X>::release () { ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::release"); X *old = this->p_; @@ -149,7 +149,7 @@ ACE_Auto_Basic_Array_Ptr<X>::operator= (ACE_Auto_Basic_Array_Ptr<X> &rhs) } template<class X> ACE_INLINE -ACE_Auto_Basic_Array_Ptr<X>::~ACE_Auto_Basic_Array_Ptr (void) +ACE_Auto_Basic_Array_Ptr<X>::~ACE_Auto_Basic_Array_Ptr () { ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::~ACE_Auto_Basic_Array_Ptr"); #if defined (ACE_HAS_ALLOC_HOOKS) diff --git a/ACE/ace/Barrier.h b/ACE/ace/Barrier.h index d6efaf2b890..58cba3f2610 100644 --- a/ACE/ace/Barrier.h +++ b/ACE/ace/Barrier.h @@ -59,7 +59,7 @@ struct ACE_Export ACE_Sub_Barrier const ACE_TCHAR *name = 0, void *arg = 0); - ~ACE_Sub_Barrier (void); + ~ACE_Sub_Barrier (); /// True if this generation of the barrier is done. ACE_Condition_Thread_Mutex barrier_finished_; @@ -68,7 +68,7 @@ struct ACE_Export ACE_Sub_Barrier int running_threads_; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -100,7 +100,7 @@ public: void *arg = 0); /// Default destructor. - ~ACE_Barrier (void); + ~ACE_Barrier (); /// Block the caller until all @c count threads have called @c wait and /// then allow all the caller threads to continue in parallel. @@ -108,7 +108,7 @@ public: /// @retval 0 after successfully waiting for all threads to wait. /// @retval -1 if an error occurs or the barrier is shut /// down (@sa shutdown ()). - int wait (void); + int wait (); /// Shut the barrier down, aborting the wait of all waiting threads. /// Any threads waiting on the barrier when it is shut down will return with @@ -117,10 +117,10 @@ public: /// @retval 0 for success, -1 if already shut down. /// /// @since ACE beta 5.4.9. - int shutdown (void); + int shutdown (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -169,10 +169,10 @@ public: ACE_Thread_Barrier (unsigned int count, const ACE_TCHAR *name = 0); /// Default destructor. - ~ACE_Thread_Barrier (void); + ~ACE_Thread_Barrier (); /// 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/Barrier.inl b/ACE/ace/Barrier.inl index f742deeb6e2..62cac458393 100644 --- a/ACE/ace/Barrier.inl +++ b/ACE/ace/Barrier.inl @@ -2,17 +2,17 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Sub_Barrier::~ACE_Sub_Barrier (void) +ACE_Sub_Barrier::~ACE_Sub_Barrier () { } ACE_INLINE -ACE_Barrier::~ACE_Barrier (void) +ACE_Barrier::~ACE_Barrier () { } ACE_INLINE -ACE_Thread_Barrier::~ACE_Thread_Barrier (void) +ACE_Thread_Barrier::~ACE_Thread_Barrier () { } diff --git a/ACE/ace/Base_Thread_Adapter.h b/ACE/ace/Base_Thread_Adapter.h index e98df29a228..5680ec8d86c 100644 --- a/ACE/ace/Base_Thread_Adapter.h +++ b/ACE/ace/Base_Thread_Adapter.h @@ -49,9 +49,9 @@ class ACE_Export ACE_OS_Thread_Descriptor { public: /// Get the thread creation flags. - long flags (void) const; + long flags () const; - virtual ~ACE_OS_Thread_Descriptor (void); + virtual ~ACE_OS_Thread_Descriptor (); protected: /// For use by ACE_Thread_Descriptor. @@ -87,14 +87,14 @@ class ACE_Service_Gestalt; class ACE_Export ACE_Base_Thread_Adapter { public: - virtual ~ACE_Base_Thread_Adapter (void); + virtual ~ACE_Base_Thread_Adapter (); /// Virtual method invoked by the thread entry point. - virtual ACE_THR_FUNC_RETURN invoke (void) = 0; + virtual ACE_THR_FUNC_RETURN invoke () = 0; /// Accessor for the C entry point function to the OS thread creation /// routine. - ACE_THR_C_FUNC entry_point (void); + ACE_THR_C_FUNC entry_point (); #ifdef ACE_USES_GPROF /// Accessor to the itimer_ @@ -103,13 +103,13 @@ public: #endif // ACE_USES_PROF /// Invoke the close_log_msg_hook, if it is present - static void close_log_msg (void); + static void close_log_msg (); /// Invoke the sync_log_msg_hook, if it is present static void sync_log_msg (const ACE_TCHAR *prog_name); /// Invoke the thr_desc_log_msg_hook, if it is present - static ACE_OS_Thread_Descriptor *thr_desc_log_msg (void); + static ACE_OS_Thread_Descriptor *thr_desc_log_msg (); protected: /// Constructor. @@ -125,7 +125,7 @@ protected: ); /// Inherit the logging features if the parent thread has an /// ACE_Log_Msg. - void inherit_log_msg (void); + void inherit_log_msg (); private: /// The hooks to inherit and cleanup the Log_Msg attributes diff --git a/ACE/ace/Base_Thread_Adapter.inl b/ACE/ace/Base_Thread_Adapter.inl index febce6f49c6..f2ea0636e59 100644 --- a/ACE/ace/Base_Thread_Adapter.inl +++ b/ACE/ace/Base_Thread_Adapter.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE long -ACE_OS_Thread_Descriptor::flags (void) const +ACE_OS_Thread_Descriptor::flags () const { return flags_; } @@ -29,7 +29,7 @@ ACE_Base_Thread_Adapter::set_log_msg_hooks ( } ACE_INLINE ACE_THR_C_FUNC -ACE_Base_Thread_Adapter::entry_point (void) +ACE_Base_Thread_Adapter::entry_point () { return this->entry_point_; } diff --git a/ACE/ace/CDR_Stream.h b/ACE/ace/CDR_Stream.h index a2d4a0ea77e..3a16dbeb7bf 100644 --- a/ACE/ace/CDR_Stream.h +++ b/ACE/ace/CDR_Stream.h @@ -165,7 +165,7 @@ public: ACE_CDR::Octet giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION); /// destructor - ~ACE_OutputCDR (void); + ~ACE_OutputCDR (); /** * Disambiguate overload when inserting booleans, octets, chars, and @@ -338,14 +338,14 @@ public: * @retval Pointer to the placeholder; 0 if there is not enough space * in the stream and memory could not be allocated. */ - char* write_long_placeholder (void); - char* write_short_placeholder (void); - char* write_boolean_placeholder (void); - char* write_char_placeholder (void); - char* write_longlong_placeholder (void); - char* write_octet_placeholder (void); - char* write_float_placeholder (void); - char* write_double_placeholder (void); + char* write_long_placeholder (); + char* write_short_placeholder (); + char* write_boolean_placeholder (); + char* write_char_placeholder (); + char* write_longlong_placeholder (); + char* write_octet_placeholder (); + char* write_float_placeholder (); + char* write_double_placeholder (); /** * Writes a new value into a specific location. This is commonly @@ -403,26 +403,26 @@ public: /** * @note The only expected error is to run out of memory. */ - bool good_bit (void) const; + bool good_bit () const; /// Reuse the CDR stream to write on the old buffer. - void reset (void); + void reset (); /// Add the length of each message block in the chain. - size_t total_length (void) const; + size_t total_length () const; /** * Return the start of the message block chain for this CDR stream. * @note The complete CDR stream is represented by a chain of * message blocks. */ - const ACE_Message_Block *begin (void) const; + const ACE_Message_Block *begin () const; /// Return the last message in the chain that is is use. - const ACE_Message_Block *end (void) const; + const ACE_Message_Block *end () const; /// Return the <current_> message block in chain. - const ACE_Message_Block *current (void) const; + const ACE_Message_Block *current () const; /// Replace the message block chain with a single message block. /** @@ -431,21 +431,21 @@ public: * * @note The only expected error is to run out of memory. */ - int consolidate (void); + int consolidate (); /** * Access the underlying buffer (read only). @note This * method only returns a pointer to the first block in the * chain. */ - const char *buffer (void) const; + const char *buffer () const; /** * Return the size of first message block in the block chain. @note This * method only returns information about the first block in the * chain. */ - size_t length (void) const; + size_t length () const; /** * Utility function to allow the user more flexibility. @@ -456,8 +456,8 @@ public: int align_write_ptr (size_t alignment); /// Access the codeset translators. They can be null! - ACE_Char_Codeset_Translator *char_translator (void) const; - ACE_WChar_Codeset_Translator *wchar_translator (void) const; + ACE_Char_Codeset_Translator *char_translator () const; + ACE_WChar_Codeset_Translator *wchar_translator () const; /// Set the char codeset translator. void char_translator (ACE_Char_Codeset_Translator *); @@ -469,14 +469,14 @@ public: static void wchar_maxbytes (size_t max_bytes); /// access the serialized size of wchars. - static size_t wchar_maxbytes (void); + static size_t wchar_maxbytes (); /** * Return alignment of the wr_ptr(), with respect to the start of * the CDR stream. This is not the same as the alignment of * current->wr_ptr()! */ - size_t current_alignment (void) const; + size_t current_alignment () const; void current_alignment (size_t current_alignment); @@ -499,11 +499,11 @@ public: /// and false otherwise. For example, it would be true if either /// ACE_ENABLE_SWAP_ON_WRITE is defined or a specific byte order was /// specified for this stream. - bool do_byte_swap (void) const; + bool do_byte_swap () const; /// Returns the byte order this stream is marshaling data in. Will be one /// of the values in ACE_CDR::Byte_Order. - int byte_order (void) const; + int byte_order () const; /// For use by a gateway, which creates the output stream for the /// reply to the client in its native byte order, but which must @@ -761,7 +761,7 @@ public: ACE_InputCDR (Transfer_Contents rhs); /// Destructor - virtual ~ACE_InputCDR (void); + virtual ~ACE_InputCDR (); /// Disambiguate overloading when extracting octets, chars, /// booleans, and bounded strings @@ -905,20 +905,20 @@ public: * Return @c false on failure and @c true on success. */ //@{ @name Skip elements - ACE_CDR::Boolean skip_boolean (void); - ACE_CDR::Boolean skip_char (void); - ACE_CDR::Boolean skip_wchar (void); - ACE_CDR::Boolean skip_octet (void); - ACE_CDR::Boolean skip_short (void); - ACE_CDR::Boolean skip_ushort (void); - ACE_CDR::Boolean skip_long (void); - ACE_CDR::Boolean skip_ulong (void); - ACE_CDR::Boolean skip_longlong (void); - ACE_CDR::Boolean skip_ulonglong (void); - ACE_CDR::Boolean skip_float (void); - ACE_CDR::Boolean skip_double (void); - ACE_CDR::Boolean skip_longdouble (void); - ACE_CDR::Boolean skip_fixed (void); + ACE_CDR::Boolean skip_boolean (); + ACE_CDR::Boolean skip_char (); + ACE_CDR::Boolean skip_wchar (); + ACE_CDR::Boolean skip_octet (); + ACE_CDR::Boolean skip_short (); + ACE_CDR::Boolean skip_ushort (); + ACE_CDR::Boolean skip_long (); + ACE_CDR::Boolean skip_ulong (); + ACE_CDR::Boolean skip_longlong (); + ACE_CDR::Boolean skip_ulonglong (); + ACE_CDR::Boolean skip_float (); + ACE_CDR::Boolean skip_double (); + ACE_CDR::Boolean skip_longdouble (); + ACE_CDR::Boolean skip_fixed (); //@} /** @@ -926,8 +926,8 @@ public: * useful in parsing a TypeCode. * @return @c false on failure and @c true on success. */ - ACE_CDR::Boolean skip_wstring (void); - ACE_CDR::Boolean skip_string (void); + ACE_CDR::Boolean skip_wstring (); + ACE_CDR::Boolean skip_string (); /// Skip @a n bytes in the CDR stream. /** @@ -936,7 +936,7 @@ public: ACE_CDR::Boolean skip_bytes (size_t n); /// returns @c false if a problem has been detected. - bool good_bit (void) const; + bool good_bit () const; /** * @return The start of the message block chain for this CDR @@ -945,7 +945,7 @@ public: * @note In the current implementation the chain has length 1, but * we are planning to change that. */ - const ACE_Message_Block* start (void) const; + const ACE_Message_Block* start () const; // = The following functions are useful to read the contents of the // CDR stream from a socket or file. @@ -970,7 +970,7 @@ public: int byte_order); /// Steal the contents from the current CDR. - ACE_Message_Block *steal_contents (void); + ACE_Message_Block *steal_contents (); /// Steal the contents of @a cdr and make a shallow copy into this /// stream. @@ -994,16 +994,16 @@ public: /// Re-initialize the CDR stream, forgetting about the old contents /// of the stream and allocating a new buffer (from the allocators). - void reset_contents (void); + void reset_contents (); /// Returns the current position for the @c rd_ptr. - char* rd_ptr (void); + char* rd_ptr (); /// Returns the current position for the @c wr_ptr. - char* wr_ptr (void); + char* wr_ptr (); /// Return how many bytes are left in the stream. - size_t length (void) const; + size_t length () const; /** * Utility function to allow the user more flexibility. @@ -1016,15 +1016,15 @@ public: /// If @c true then this stream is writing in non-native byte order. /// This is only meaningful if ACE_ENABLE_SWAP_ON_WRITE is defined. - bool do_byte_swap (void) const; + bool do_byte_swap () const; /// If @c do_byte_swap() returns @c false, this returns /// ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER. - int byte_order (void) const; + int byte_order () const; /// Access the codeset translators. They can be nil! - ACE_Char_Codeset_Translator *char_translator (void) const; - ACE_WChar_Codeset_Translator *wchar_translator (void) const; + ACE_Char_Codeset_Translator *char_translator () const; + ACE_WChar_Codeset_Translator *wchar_translator () const; /// Set the codeset translators. void char_translator (ACE_Char_Codeset_Translator *); @@ -1126,7 +1126,7 @@ private: void rd_ptr (size_t offset); /// Points to the continuation field of the current message block. - char* end (void); + char* end (); }; // **************************************************************** diff --git a/ACE/ace/CDR_Stream.inl b/ACE/ace/CDR_Stream.inl index 69810663b82..3ee06d67ef4 100644 --- a/ACE/ace/CDR_Stream.inl +++ b/ACE/ace/CDR_Stream.inl @@ -170,7 +170,7 @@ ACE_InputCDR::Transfer_Contents::Transfer_Contents (ACE_InputCDR &rhs) // **************************************************************** ACE_INLINE -ACE_OutputCDR::~ACE_OutputCDR (void) +ACE_OutputCDR::~ACE_OutputCDR () { if (this->start_.cont () != 0) { @@ -186,7 +186,7 @@ ACE_OutputCDR::~ACE_OutputCDR (void) } ACE_INLINE void -ACE_OutputCDR::reset (void) +ACE_OutputCDR::reset () { this->current_ = &this->start_; this->current_is_writable_ = true; @@ -492,7 +492,7 @@ ACE_OutputCDR::write_longdouble_array (const ACE_CDR::LongDouble* x, } ACE_INLINE bool -ACE_OutputCDR::good_bit (void) const +ACE_OutputCDR::good_bit () const { return this->good_bit_; } @@ -557,49 +557,49 @@ ACE_OutputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor) ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::begin (void) const +ACE_OutputCDR::begin () const { return &this->start_; } ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::end (void) const +ACE_OutputCDR::end () const { return this->current_->cont (); } ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::current (void) const +ACE_OutputCDR::current () const { return this->current_; } ACE_INLINE size_t -ACE_OutputCDR::total_length (void) const +ACE_OutputCDR::total_length () const { return ACE_CDR::total_length (this->begin (), this->end ()); } ACE_INLINE const char* -ACE_OutputCDR::buffer (void) const +ACE_OutputCDR::buffer () const { return this->start_.rd_ptr (); } ACE_INLINE size_t -ACE_OutputCDR::length (void) const +ACE_OutputCDR::length () const { return this->start_.length (); } ACE_INLINE bool -ACE_OutputCDR::do_byte_swap (void) const +ACE_OutputCDR::do_byte_swap () const { return this->do_byte_swap_; } ACE_INLINE int -ACE_OutputCDR::byte_order (void) const +ACE_OutputCDR::byte_order () const { if (this->do_byte_swap ()) return !ACE_CDR_BYTE_ORDER; @@ -614,7 +614,7 @@ ACE_OutputCDR::reset_byte_order (int byte_order) } ACE_INLINE size_t -ACE_OutputCDR::current_alignment (void) const +ACE_OutputCDR::current_alignment () const { #if !defined (ACE_LACKS_CDR_ALIGNMENT) return this->current_alignment_; @@ -649,13 +649,13 @@ ACE_OutputCDR::align_write_ptr (size_t alignment) } ACE_INLINE ACE_Char_Codeset_Translator * -ACE_OutputCDR::char_translator (void) const +ACE_OutputCDR::char_translator () const { return this->char_translator_; } ACE_INLINE ACE_WChar_Codeset_Translator * -ACE_OutputCDR::wchar_translator (void) const +ACE_OutputCDR::wchar_translator () const { return this->wchar_translator_; } @@ -675,7 +675,7 @@ ACE_OutputCDR::wchar_translator (ACE_WChar_Codeset_Translator * wctran) // **************************************************************** ACE_INLINE -ACE_InputCDR::~ACE_InputCDR (void) +ACE_InputCDR::~ACE_InputCDR () { #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) this->monitor_->remove_ref (); @@ -792,7 +792,7 @@ ACE_InputCDR::read_fixed (ACE_CDR::Fixed &x) } ACE_INLINE size_t -ACE_InputCDR::length (void) const +ACE_InputCDR::length () const { return this->start_.length (); } @@ -1022,84 +1022,84 @@ ACE_InputCDR::read_longdouble_array (ACE_CDR::LongDouble* x, } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_octet (void) +ACE_InputCDR::skip_octet () { ACE_CDR::Octet x; return this->read_1 (&x); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_char (void) +ACE_InputCDR::skip_char () { return this->skip_octet (); // sizeof (Char) == sizeof (Octet) } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_boolean (void) +ACE_InputCDR::skip_boolean () { return this->skip_octet () && this->good_bit_; } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ushort (void) +ACE_InputCDR::skip_ushort () { ACE_CDR::UShort x; return this->read_2 (&x); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_short (void) +ACE_InputCDR::skip_short () { return this->skip_ushort (); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ulong (void) +ACE_InputCDR::skip_ulong () { ACE_CDR::ULong x; return this->read_4 (&x); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_long (void) +ACE_InputCDR::skip_long () { return this->skip_ulong (); // sizeof (Long) == sizeof (ULong) } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ulonglong (void) +ACE_InputCDR::skip_ulonglong () { ACE_CDR::ULongLong x; return this->read_8 (&x); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_longlong (void) +ACE_InputCDR::skip_longlong () { return this->skip_ulonglong (); // sizeof (LongLong) == sizeof (ULongLong) } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_float (void) +ACE_InputCDR::skip_float () { return this->skip_ulong (); // sizeof(Float) == sizeof (ULong) } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_double (void) +ACE_InputCDR::skip_double () { return this->skip_ulonglong (); // sizeof(Double) == sizeof (ULongLong) } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_longdouble (void) +ACE_InputCDR::skip_longdouble () { ACE_CDR::LongDouble x; return this->read_16 (&x); } ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_fixed (void) +ACE_InputCDR::skip_fixed () { for (int i = 0; i < 16; ++i) { @@ -1114,7 +1114,7 @@ ACE_InputCDR::skip_fixed (void) } ACE_INLINE char* -ACE_InputCDR::end (void) +ACE_InputCDR::end () { return this->start_.end (); } @@ -1126,13 +1126,13 @@ ACE_InputCDR::rd_ptr (size_t offset) } ACE_INLINE char* -ACE_InputCDR::rd_ptr (void) +ACE_InputCDR::rd_ptr () { return this->start_.rd_ptr (); } ACE_INLINE char* -ACE_InputCDR::wr_ptr (void) +ACE_InputCDR::wr_ptr () { return this->start_.wr_ptr (); } @@ -1170,13 +1170,13 @@ ACE_InputCDR::adjust (size_t size, } ACE_INLINE const ACE_Message_Block* -ACE_InputCDR::start (void) const +ACE_InputCDR::start () const { return &this->start_; } ACE_INLINE bool -ACE_InputCDR::good_bit (void) const +ACE_InputCDR::good_bit () const { return this->good_bit_; } @@ -1675,13 +1675,13 @@ ACE_InputCDR::reset_byte_order (int byte_order) } ACE_INLINE bool -ACE_InputCDR::do_byte_swap (void) const +ACE_InputCDR::do_byte_swap () const { return this->do_byte_swap_; } ACE_INLINE int -ACE_InputCDR::byte_order (void) const +ACE_InputCDR::byte_order () const { return this->do_byte_swap () ? !ACE_CDR_BYTE_ORDER : ACE_CDR_BYTE_ORDER; } @@ -1721,13 +1721,13 @@ ACE_InputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor) } ACE_INLINE ACE_Char_Codeset_Translator * -ACE_InputCDR::char_translator (void) const +ACE_InputCDR::char_translator () const { return this->char_translator_; } ACE_INLINE ACE_WChar_Codeset_Translator * -ACE_InputCDR::wchar_translator (void) const +ACE_InputCDR::wchar_translator () const { return this->wchar_translator_; } diff --git a/ACE/ace/Cleanup.h b/ACE/ace/Cleanup.h index afc23f2e419..7f839901d1f 100644 --- a/ACE/ace/Cleanup.h +++ b/ACE/ace/Cleanup.h @@ -46,10 +46,10 @@ class ACE_Export ACE_Cleanup { public: /// No-op constructor. - ACE_Cleanup (void); + ACE_Cleanup (); /// Destructor. - virtual ~ACE_Cleanup (void); + virtual ~ACE_Cleanup (); /// Cleanup method that, by default, simply deletes itself. virtual void cleanup (void *param = 0); @@ -69,12 +69,12 @@ void ACE_CLEANUP_DESTROYER_NAME (ACE_Cleanup *, void *param = 0); class ACE_Cleanup_Info_Node : public ACE_Intrusive_List_Node<ACE_Cleanup_Info_Node> { public: - ACE_Cleanup_Info_Node (void); + ACE_Cleanup_Info_Node (); ACE_Cleanup_Info_Node (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param, const char *name); - ~ACE_Cleanup_Info_Node (void); + ~ACE_Cleanup_Info_Node (); /// Equality operator. bool operator== (const ACE_Cleanup_Info_Node &o) const; @@ -82,11 +82,11 @@ public: /// Inequality operator. bool operator!= (const ACE_Cleanup_Info_Node &o) const; - void* object(void); + void* object(); - ACE_CLEANUP_FUNC cleanup_hook (void); + ACE_CLEANUP_FUNC cleanup_hook (); - void *param (void); + void *param (); ACE_ALLOC_HOOK_DECLARE; @@ -119,10 +119,10 @@ class ACE_Export ACE_OS_Exit_Info { public: /// Default constructor. - ACE_OS_Exit_Info (void); + ACE_OS_Exit_Info (); /// Destructor. - ~ACE_OS_Exit_Info (void); + ~ACE_OS_Exit_Info (); /// Use to register a cleanup hook. int at_exit_i (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param, const char* name = 0); diff --git a/ACE/ace/Cleanup.inl b/ACE/ace/Cleanup.inl index fdae3412f65..44b8ce91d22 100644 --- a/ACE/ace/Cleanup.inl +++ b/ACE/ace/Cleanup.inl @@ -2,24 +2,24 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Cleanup::ACE_Cleanup (void) +ACE_Cleanup::ACE_Cleanup () { } ACE_INLINE void* -ACE_Cleanup_Info_Node::object(void) +ACE_Cleanup_Info_Node::object() { return this->object_; } ACE_INLINE ACE_CLEANUP_FUNC -ACE_Cleanup_Info_Node::cleanup_hook (void) +ACE_Cleanup_Info_Node::cleanup_hook () { return this->cleanup_hook_; } ACE_INLINE void * -ACE_Cleanup_Info_Node::param (void) +ACE_Cleanup_Info_Node::param () { return this->param_; } diff --git a/ACE/ace/Condition_Attributes.h b/ACE/ace/Condition_Attributes.h index 06b2676d8ae..b678536da34 100644 --- a/ACE/ace/Condition_Attributes.h +++ b/ACE/ace/Condition_Attributes.h @@ -31,10 +31,10 @@ public: ACE_Condition_Attributes (int type = ACE_DEFAULT_SYNCH_TYPE); /// Destructor - ~ACE_Condition_Attributes (void); + ~ACE_Condition_Attributes (); /// Accessor for retrieving the current attributes - const ACE_condattr_t& attributes (void) const; + const ACE_condattr_t& attributes () const; protected: /// The attributes @@ -56,7 +56,7 @@ public: {} /// Destructor - ~ACE_Condition_Attributes_T (void) {} + ~ACE_Condition_Attributes_T () {} private: // = Prevent assignment and initialization. @@ -75,7 +75,7 @@ public: ACE_Condition_Attributes_T (int type = ACE_DEFAULT_SYNCH_TYPE); /// Destructor - ~ACE_Condition_Attributes_T (void); + ~ACE_Condition_Attributes_T (); private: // = Prevent assignment and initialization. diff --git a/ACE/ace/Condition_Attributes.inl b/ACE/ace/Condition_Attributes.inl index f63106ad4e0..4fb4f788b3e 100644 --- a/ACE/ace/Condition_Attributes.inl +++ b/ACE/ace/Condition_Attributes.inl @@ -8,14 +8,14 @@ ACE_Condition_Attributes::ACE_Condition_Attributes (int type) } ACE_INLINE -ACE_Condition_Attributes::~ACE_Condition_Attributes (void) +ACE_Condition_Attributes::~ACE_Condition_Attributes () { ACE_OS::condattr_destroy (this->attributes_); } ACE_INLINE const ACE_condattr_t& -ACE_Condition_Attributes::attributes (void) const +ACE_Condition_Attributes::attributes () const { return this->attributes_; } @@ -30,7 +30,7 @@ ACE_Condition_Attributes_T<ACE_Monotonic_Time_Policy>::ACE_Condition_Attributes_ } ACE_INLINE -ACE_Condition_Attributes_T<ACE_Monotonic_Time_Policy>::~ACE_Condition_Attributes_T (void) +ACE_Condition_Attributes_T<ACE_Monotonic_Time_Policy>::~ACE_Condition_Attributes_T () { } diff --git a/ACE/ace/Condition_Recursive_Thread_Mutex.h b/ACE/ace/Condition_Recursive_Thread_Mutex.h index f53ab12ebfd..816f08c7f2c 100644 --- a/ACE/ace/Condition_Recursive_Thread_Mutex.h +++ b/ACE/ace/Condition_Recursive_Thread_Mutex.h @@ -46,14 +46,14 @@ public: const ACE_Condition_Attributes &attributes); /// Implicitly destroy the condition variable. - ~ACE_Condition (void); + ~ACE_Condition (); /** * Explicitly destroy the condition variable. Note that only one * thread should call this method since it doesn't protect against * race conditions. */ - int remove (void); + int remove (); /** * Block on condition, or until absolute time-of-day has passed. If @@ -75,16 +75,16 @@ public: const ACE_Time_Value *abstime = 0); /// Signal one waiting thread. - int signal (void); + int signal (); /// Signal *all* waiting threads. - int broadcast (void); + int broadcast (); /// Returns a reference to the underlying mutex; - ACE_Recursive_Thread_Mutex &mutex (void); + ACE_Recursive_Thread_Mutex &mutex (); /// Dump the state of an object. - void dump (void) const; + void dump () const; private: // = Prevent assignment and copying. diff --git a/ACE/ace/Condition_T.cpp b/ACE/ace/Condition_T.cpp index 7f6b16737f0..3c16a20201f 100644 --- a/ACE/ace/Condition_T.cpp +++ b/ACE/ace/Condition_T.cpp @@ -25,7 +25,7 @@ ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Condition) ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Thread_Condition) template <class MUTEX> void -ACE_Condition<MUTEX>::dump (void) const +ACE_Condition<MUTEX>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Condition<MUTEX>::dump"); @@ -46,7 +46,7 @@ ACE_Thread_Condition<MUTEX>::ACE_Thread_Condition (MUTEX &m, } template <class MUTEX> void -ACE_Thread_Condition<MUTEX>::dump (void) const +ACE_Thread_Condition<MUTEX>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Thread_Condition<MUTEX>::dump"); @@ -91,7 +91,7 @@ ACE_Condition<MUTEX>::ACE_Condition (MUTEX &m, } template <class MUTEX> -ACE_Condition<MUTEX>::~ACE_Condition (void) +ACE_Condition<MUTEX>::~ACE_Condition () { // ACE_TRACE ("ACE_Condition<MUTEX>::~ACE_Condition"); @@ -102,7 +102,7 @@ ACE_Condition<MUTEX>::~ACE_Condition (void) } template <class MUTEX> int -ACE_Condition<MUTEX>::wait (void) +ACE_Condition<MUTEX>::wait () { // ACE_TRACE ("ACE_Condition<MUTEX>::wait"); return ACE_OS::cond_wait (&this->cond_, diff --git a/ACE/ace/Condition_T.h b/ACE/ace/Condition_T.h index d87d96b2dc5..0f709e4814e 100644 --- a/ACE/ace/Condition_T.h +++ b/ACE/ace/Condition_T.h @@ -63,7 +63,7 @@ public: void *arg = 0); /// Implicitly destroy the condition variable. - ~ACE_Condition (void); + ~ACE_Condition (); // = Lock accessors. /** @@ -75,7 +75,7 @@ public: int wait (const ACE_Time_Value *abstime); /// Block on condition. - int wait (void); + int wait (); /** * Block on condition or until absolute time-of-day has passed. If @@ -88,20 +88,20 @@ public: int wait (MUTEX &mutex, const ACE_Time_Value *abstime = 0); /// Signal one waiting thread. - int signal (void); + int signal (); /// Signal *all* waiting threads. - int broadcast (void); + int broadcast (); // = Utility methods. /// Explicitly destroy the condition variable. - int remove (void); + int remove (); /// Returns a reference to the underlying mutex_; - MUTEX &mutex (void); + MUTEX &mutex (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -143,7 +143,7 @@ public: ACE_Thread_Condition (MUTEX &m, const ACE_TCHAR *name = 0, void *arg = 0); /// 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/Condition_T.inl b/ACE/ace/Condition_T.inl index dc426622988..c919464b1ad 100644 --- a/ACE/ace/Condition_T.inl +++ b/ACE/ace/Condition_T.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class MUTEX> ACE_INLINE int -ACE_Condition<MUTEX>::remove (void) +ACE_Condition<MUTEX>::remove () { // ACE_TRACE ("ACE_Condition<MUTEX>::remove"); @@ -25,21 +25,21 @@ ACE_Condition<MUTEX>::remove (void) } template<class MUTEX> ACE_INLINE MUTEX & -ACE_Condition<MUTEX>::mutex (void) +ACE_Condition<MUTEX>::mutex () { // ACE_TRACE ("ACE_Condition<MUTEX>::mutex"); return this->mutex_; } template <class MUTEX> ACE_INLINE int -ACE_Condition<MUTEX>::signal (void) +ACE_Condition<MUTEX>::signal () { // ACE_TRACE ("ACE_Condition<MUTEX>::signal"); return ACE_OS::cond_signal (&this->cond_); } template <class MUTEX> ACE_INLINE int -ACE_Condition<MUTEX>::broadcast (void) +ACE_Condition<MUTEX>::broadcast () { // ACE_TRACE ("ACE_Condition<MUTEX>::broadcast"); return ACE_OS::cond_broadcast (&this->cond_); diff --git a/ACE/ace/Condition_Thread_Mutex.h b/ACE/ace/Condition_Thread_Mutex.h index 898e683fab6..855adcba377 100644 --- a/ACE/ace/Condition_Thread_Mutex.h +++ b/ACE/ace/Condition_Thread_Mutex.h @@ -65,14 +65,14 @@ public: void *arg = 0); /// Implicitly destroy the condition variable. - ~ACE_Condition (void); + ~ACE_Condition (); /** * Explicitly destroy the condition variable. Note that only one * thread should call this method since it doesn't protect against * race conditions. */ - int remove (void); + int remove (); /** * Block on condition, or until absolute time-of-day has passed. If @@ -83,7 +83,7 @@ public: int wait (const ACE_Time_Value *abstime); /// Block on condition. - int wait (void); + int wait (); /** * Block on condition or until absolute time-of-day has passed. If @@ -96,16 +96,16 @@ public: int wait (ACE_Thread_Mutex &mutex, const ACE_Time_Value *abstime = 0); /// Signal one waiting thread. - int signal (void); + int signal (); /// Signal *all* waiting threads. - int broadcast (void); + int broadcast (); /// Returns a reference to the underlying mutex; - ACE_Thread_Mutex &mutex (void); + ACE_Thread_Mutex &mutex (); /// 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/Condition_Thread_Mutex.inl b/ACE/ace/Condition_Thread_Mutex.inl index 5db2808d1a3..614d9f0eb87 100644 --- a/ACE/ace/Condition_Thread_Mutex.inl +++ b/ACE/ace/Condition_Thread_Mutex.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int -ACE_Condition<ACE_Thread_Mutex>::remove (void) +ACE_Condition<ACE_Thread_Mutex>::remove () { // ACE_TRACE ("ACE_Condition<ACE_Thread_Mutex>::remove"); @@ -29,7 +29,7 @@ ACE_Condition<ACE_Thread_Mutex>::remove (void) } ACE_INLINE ACE_Thread_Mutex & -ACE_Condition<ACE_Thread_Mutex>::mutex (void) +ACE_Condition<ACE_Thread_Mutex>::mutex () { // ACE_TRACE ("ACE_Condition<ACE_Thread_Mutex>::mutex"); return this->mutex_; diff --git a/ACE/ace/Containers.h b/ACE/ace/Containers.h index 4d671ca9808..8ba4c3c84a6 100644 --- a/ACE/ace/Containers.h +++ b/ACE/ace/Containers.h @@ -53,7 +53,7 @@ public: ACE_DLList_Node *prev_; protected: - ACE_DLList_Node (void); + ACE_DLList_Node (); }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/Containers.inl b/ACE/ace/Containers.inl index cd7507d403b..ed3e183a370 100644 --- a/ACE/ace/Containers.inl +++ b/ACE/ace/Containers.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_DLList_Node::ACE_DLList_Node (void) +ACE_DLList_Node::ACE_DLList_Node () : item_ (0), next_ (0), prev_ (0) diff --git a/ACE/ace/Containers_T.cpp b/ACE/ace/Containers_T.cpp index 4fa39569b46..2c69a6b0c6e 100644 --- a/ACE/ace/Containers_T.cpp +++ b/ACE/ace/Containers_T.cpp @@ -20,7 +20,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Stack) template <class T> void -ACE_Bounded_Stack<T>::dump (void) const +ACE_Bounded_Stack<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Bounded_Stack<T>::dump"); @@ -73,7 +73,7 @@ ACE_Bounded_Stack<T>::operator= (const ACE_Bounded_Stack<T> &s) } template<class T> -ACE_Bounded_Stack<T>::~ACE_Bounded_Stack (void) +ACE_Bounded_Stack<T>::~ACE_Bounded_Stack () { ACE_TRACE ("ACE_Bounded_Stack<T>::~ACE_Bounded_Stack"); delete [] this->stack_; @@ -84,7 +84,7 @@ ACE_Bounded_Stack<T>::~ACE_Bounded_Stack (void) ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Stack) template <class T, size_t ACE_SIZE> void -ACE_Fixed_Stack<T, ACE_SIZE>::dump (void) const +ACE_Fixed_Stack<T, ACE_SIZE>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::dump"); @@ -92,7 +92,7 @@ ACE_Fixed_Stack<T, ACE_SIZE>::dump (void) const } template<class T, size_t ACE_SIZE> -ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack (void) +ACE_Fixed_Stack<T, ACE_SIZE>::ACE_Fixed_Stack () : size_ (ACE_SIZE), top_ (0) { @@ -124,7 +124,7 @@ ACE_Fixed_Stack<T, ACE_SIZE>::operator= (const ACE_Fixed_Stack<T, ACE_SIZE> &s) } template<class T, size_t ACE_SIZE> -ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack (void) +ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack () { ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack"); } @@ -134,7 +134,7 @@ ACE_Fixed_Stack<T, ACE_SIZE>::~ACE_Fixed_Stack (void) ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Unbounded_Stack) template <class T> void -ACE_Unbounded_Stack<T>::dump (void) const +ACE_Unbounded_Stack<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Stack<T>::dump"); @@ -158,7 +158,7 @@ ACE_Unbounded_Stack<T>::ACE_Unbounded_Stack (ACE_Allocator *alloc) } template<class T> void -ACE_Unbounded_Stack<T>::delete_all_nodes (void) +ACE_Unbounded_Stack<T>::delete_all_nodes () { // ACE_TRACE ("ACE_Unbounded_Stack<T>::delete_all_nodes"); @@ -229,7 +229,7 @@ ACE_Unbounded_Stack<T>::operator= (const ACE_Unbounded_Stack<T> &s) } template<class T> -ACE_Unbounded_Stack<T>::~ACE_Unbounded_Stack (void) +ACE_Unbounded_Stack<T>::~ACE_Unbounded_Stack () { // ACE_TRACE ("ACE_Unbounded_Stack<T>::~ACE_Unbounded_Stack"); @@ -356,7 +356,7 @@ ACE_Double_Linked_List_Iterator_Base<T>::ACE_Double_Linked_List_Iterator_Base (c template <class T> T * -ACE_Double_Linked_List_Iterator_Base<T>::next (void) const +ACE_Double_Linked_List_Iterator_Base<T>::next () const { return this->not_done (); } @@ -370,13 +370,13 @@ ACE_Double_Linked_List_Iterator_Base<T>::next (T *&ptr) const template <class T> int -ACE_Double_Linked_List_Iterator_Base<T>::done (void) const +ACE_Double_Linked_List_Iterator_Base<T>::done () const { return this->not_done () ? 0 : 1; } template <class T> T & -ACE_Double_Linked_List_Iterator_Base<T>::operator* (void) const +ACE_Double_Linked_List_Iterator_Base<T>::operator* () const { return *(this->not_done ()); } @@ -391,21 +391,21 @@ ACE_Double_Linked_List_Iterator_Base<T>::reset (ACE_Double_Linked_List<T> &dll) } template <class T> int -ACE_Double_Linked_List_Iterator_Base<T>::go_head (void) +ACE_Double_Linked_List_Iterator_Base<T>::go_head () { this->current_ = static_cast<T*> (dllist_->head_->next_); return this->current_ ? 1 : 0; } template <class T> int -ACE_Double_Linked_List_Iterator_Base<T>::go_tail (void) +ACE_Double_Linked_List_Iterator_Base<T>::go_tail () { this->current_ = static_cast<T*> (dllist_->head_->prev_); return this->current_ ? 1 : 0; } template <class T> T * -ACE_Double_Linked_List_Iterator_Base<T>::not_done (void) const +ACE_Double_Linked_List_Iterator_Base<T>::not_done () const { if (this->current_ != this->dllist_->head_) return this->current_; @@ -414,7 +414,7 @@ ACE_Double_Linked_List_Iterator_Base<T>::not_done (void) const } template <class T> T * -ACE_Double_Linked_List_Iterator_Base<T>::do_advance (void) +ACE_Double_Linked_List_Iterator_Base<T>::do_advance () { if (this->not_done ()) { @@ -426,7 +426,7 @@ ACE_Double_Linked_List_Iterator_Base<T>::do_advance (void) } template <class T> T * -ACE_Double_Linked_List_Iterator_Base<T>::do_retreat (void) +ACE_Double_Linked_List_Iterator_Base<T>::do_retreat () { if (this->not_done ()) { @@ -438,7 +438,7 @@ ACE_Double_Linked_List_Iterator_Base<T>::do_retreat (void) } template <class T> void -ACE_Double_Linked_List_Iterator_Base<T>::dump_i (void) const +ACE_Double_Linked_List_Iterator_Base<T>::dump_i () const { ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("current_ = %x"), this->current_)); @@ -467,13 +467,13 @@ ACE_Double_Linked_List_Iterator<T>::reset (ACE_Double_Linked_List<T> &dll) } template <class T> int -ACE_Double_Linked_List_Iterator<T>::first (void) +ACE_Double_Linked_List_Iterator<T>::first () { return this->go_head (); } template <class T> int -ACE_Double_Linked_List_Iterator<T>::advance (void) +ACE_Double_Linked_List_Iterator<T>::advance () { return this->do_advance () ? 1 : 0; } @@ -497,7 +497,7 @@ ACE_Double_Linked_List_Iterator<T>::advance_and_remove (bool dont_remove) } template <class T> void -ACE_Double_Linked_List_Iterator<T>::dump (void) const +ACE_Double_Linked_List_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -508,7 +508,7 @@ ACE_Double_Linked_List_Iterator<T>::dump (void) const template <class T> ACE_Double_Linked_List_Iterator<T> & -ACE_Double_Linked_List_Iterator<T>::operator++ (void) +ACE_Double_Linked_List_Iterator<T>::operator++ () { this->do_advance (); return *this; @@ -531,7 +531,7 @@ ACE_Double_Linked_List_Iterator<T>::operator++ (int) template <class T> ACE_Double_Linked_List_Iterator<T> & -ACE_Double_Linked_List_Iterator<T>::operator-- (void) +ACE_Double_Linked_List_Iterator<T>::operator-- () { this->do_retreat (); return *this; @@ -572,13 +572,13 @@ ACE_Double_Linked_List_Reverse_Iterator<T>::reset (ACE_Double_Linked_List<T> &dl } template <class T> int -ACE_Double_Linked_List_Reverse_Iterator<T>::first (void) +ACE_Double_Linked_List_Reverse_Iterator<T>::first () { return this->go_tail (); } template <class T> int -ACE_Double_Linked_List_Reverse_Iterator<T>::advance (void) +ACE_Double_Linked_List_Reverse_Iterator<T>::advance () { return this->do_retreat () ? 1 : 0; } @@ -604,7 +604,7 @@ ACE_Double_Linked_List_Reverse_Iterator<T>::advance_and_remove (bool dont_remove } template <class T> void -ACE_Double_Linked_List_Reverse_Iterator<T>::dump (void) const +ACE_Double_Linked_List_Reverse_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -615,7 +615,7 @@ ACE_Double_Linked_List_Reverse_Iterator<T>::dump (void) const template <class T> ACE_Double_Linked_List_Reverse_Iterator<T> & -ACE_Double_Linked_List_Reverse_Iterator<T>::operator++ (void) +ACE_Double_Linked_List_Reverse_Iterator<T>::operator++ () { this->do_retreat (); return *this; @@ -638,7 +638,7 @@ ACE_Double_Linked_List_Reverse_Iterator<T>::operator++ (int) template <class T> ACE_Double_Linked_List_Reverse_Iterator<T> & -ACE_Double_Linked_List_Reverse_Iterator<T>::operator-- (void) +ACE_Double_Linked_List_Reverse_Iterator<T>::operator-- () { this->do_advance (); return *this; @@ -698,7 +698,7 @@ ACE_Double_Linked_List<T>::operator= (const ACE_Double_Linked_List<T> &cx) } template <class T> -ACE_Double_Linked_List<T>::~ACE_Double_Linked_List (void) +ACE_Double_Linked_List<T>::~ACE_Double_Linked_List () { this->delete_nodes (); @@ -710,13 +710,13 @@ ACE_Double_Linked_List<T>::~ACE_Double_Linked_List (void) } template <class T> int -ACE_Double_Linked_List<T>::is_empty (void) const +ACE_Double_Linked_List<T>::is_empty () const { return this->size () ? 0 : 1; } template <class T> int -ACE_Double_Linked_List<T>::is_full (void) const +ACE_Double_Linked_List<T>::is_full () const { return 0; // We have no bound. } @@ -737,7 +737,7 @@ ACE_Double_Linked_List<T>::insert_head (T *new_item) } template <class T> T * -ACE_Double_Linked_List<T>::delete_head (void) +ACE_Double_Linked_List<T>::delete_head () { if (this->is_empty ()) return 0; @@ -749,7 +749,7 @@ ACE_Double_Linked_List<T>::delete_head (void) } template <class T> T * -ACE_Double_Linked_List<T>::delete_tail (void) +ACE_Double_Linked_List<T>::delete_tail () { if (this->is_empty ()) return 0; @@ -761,7 +761,7 @@ ACE_Double_Linked_List<T>::delete_tail (void) } template <class T> void -ACE_Double_Linked_List<T>::reset (void) +ACE_Double_Linked_List<T>::reset () { this->delete_nodes (); } @@ -781,13 +781,13 @@ ACE_Double_Linked_List<T>::get (T *&item, size_t slot) } template <class T> size_t -ACE_Double_Linked_List<T>::size (void) const +ACE_Double_Linked_List<T>::size () const { return this->size_; } template <class T> void -ACE_Double_Linked_List<T>::dump (void) const +ACE_Double_Linked_List<T>::dump () const { #if defined (ACE_HAS_DUMP) // Dump the state of an object. @@ -801,7 +801,7 @@ ACE_Double_Linked_List<T>::remove (T *n) } template <class T> void -ACE_Double_Linked_List<T>::delete_nodes (void) +ACE_Double_Linked_List<T>::delete_nodes () { while (! this->is_empty ()) { @@ -829,7 +829,7 @@ ACE_Double_Linked_List<T>::copy_nodes (const ACE_Double_Linked_List<T> &c) } template <class T> void -ACE_Double_Linked_List<T>::init_head (void) +ACE_Double_Linked_List<T>::init_head () { this->head_->next_ = this->head_; this->head_->prev_ = this->head_; @@ -875,14 +875,14 @@ ACE_Double_Linked_List<T>::remove_element (T *item) ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set) template <class T, size_t ACE_SIZE> size_t -ACE_Fixed_Set<T, ACE_SIZE>::size (void) const +ACE_Fixed_Set<T, ACE_SIZE>::size () const { ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::size"); return this->cur_size_; } template <class T, size_t ACE_SIZE> void -ACE_Fixed_Set<T, ACE_SIZE>::dump (void) const +ACE_Fixed_Set<T, ACE_SIZE>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::dump"); @@ -890,7 +890,7 @@ ACE_Fixed_Set<T, ACE_SIZE>::dump (void) const } template <class T, size_t ACE_SIZE> -ACE_Fixed_Set<T, ACE_SIZE>::~ACE_Fixed_Set (void) +ACE_Fixed_Set<T, ACE_SIZE>::~ACE_Fixed_Set () { ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::~ACE_Fixed_Set"); this->cur_size_ = 0; @@ -923,7 +923,7 @@ ACE_Fixed_Set<T, ACE_SIZE>::operator= (const ACE_Fixed_Set<T, ACE_SIZE> &fs) } template <class T, size_t ACE_SIZE> -ACE_Fixed_Set<T, ACE_SIZE>::ACE_Fixed_Set (void) +ACE_Fixed_Set<T, ACE_SIZE>::ACE_Fixed_Set () : cur_size_ (0), max_size_ (ACE_SIZE) { @@ -1014,7 +1014,7 @@ ACE_Fixed_Set<T, ACE_SIZE>::remove (const T &item) ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Iterator_Base) template <class T, size_t ACE_SIZE> void -ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::dump_i (void) const +ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::dump_i () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::dump_i"); @@ -1032,7 +1032,7 @@ ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::ACE_Fixed_Set_Iterator_Base (ACE_Fixed } template <class T, size_t ACE_SIZE> int -ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance (void) +ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance () { ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance"); @@ -1054,7 +1054,7 @@ ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::advance (void) } template <class T, size_t ACE_SIZE> int -ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first (void) +ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first () { ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first"); @@ -1064,7 +1064,7 @@ ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::first (void) } template <class T, size_t ACE_SIZE> int -ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::done (void) const +ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::done () const { ACE_TRACE ("ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::done"); @@ -1095,7 +1095,7 @@ ACE_Fixed_Set_Iterator_Base<T, ACE_SIZE>::next_i (T *&item) ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Iterator) template <class T, size_t ACE_SIZE> void -ACE_Fixed_Set_Iterator<T, ACE_SIZE>::dump (void) const +ACE_Fixed_Set_Iterator<T, ACE_SIZE>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -1133,7 +1133,7 @@ ACE_Fixed_Set_Iterator<T, ACE_SIZE>::remove (T *&item) } template <class T, size_t ACE_SIZE> T& -ACE_Fixed_Set_Iterator<T, ACE_SIZE>::operator* (void) +ACE_Fixed_Set_Iterator<T, ACE_SIZE>::operator* () { T *retv = 0; @@ -1149,7 +1149,7 @@ ACE_Fixed_Set_Iterator<T, ACE_SIZE>::operator* (void) ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Const_Iterator) template <class T, size_t ACE_SIZE> void -ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::dump (void) const +ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -1172,7 +1172,7 @@ ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::next (const T *&item) } template <class T, size_t ACE_SIZE> const T& -ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::operator* (void) const +ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::operator* () const { const T *retv = 0; @@ -1188,7 +1188,7 @@ ACE_Fixed_Set_Const_Iterator<T, ACE_SIZE>::operator* (void) const ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Set) template <class T> void -ACE_Bounded_Set<T>::dump (void) const +ACE_Bounded_Set<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Bounded_Set<T>::dump"); @@ -1196,14 +1196,14 @@ ACE_Bounded_Set<T>::dump (void) const } template <class T> -ACE_Bounded_Set<T>::~ACE_Bounded_Set (void) +ACE_Bounded_Set<T>::~ACE_Bounded_Set () { ACE_TRACE ("ACE_Bounded_Set<T>::~ACE_Bounded_Set"); delete [] this->search_structure_; } template <class T> -ACE_Bounded_Set<T>::ACE_Bounded_Set (void) +ACE_Bounded_Set<T>::ACE_Bounded_Set () : cur_size_ (0), max_size_ (static_cast<size_t> (ACE_Bounded_Set<T>::DEFAULT_SIZE)) { @@ -1217,7 +1217,7 @@ ACE_Bounded_Set<T>::ACE_Bounded_Set (void) } template <class T> size_t -ACE_Bounded_Set<T>::size (void) const +ACE_Bounded_Set<T>::size () const { ACE_TRACE ("ACE_Bounded_Set<T>::size"); return this->cur_size_; @@ -1352,7 +1352,7 @@ ACE_Bounded_Set<T>::remove (const T &item) ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Set_Iterator) template <class T> void -ACE_Bounded_Set_Iterator<T>::dump (void) const +ACE_Bounded_Set_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::dump"); @@ -1369,7 +1369,7 @@ ACE_Bounded_Set_Iterator<T>::ACE_Bounded_Set_Iterator (ACE_Bounded_Set<T> &s) } template <class T> int -ACE_Bounded_Set_Iterator<T>::advance (void) +ACE_Bounded_Set_Iterator<T>::advance () { ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::advance"); @@ -1383,7 +1383,7 @@ ACE_Bounded_Set_Iterator<T>::advance (void) } template <class T> int -ACE_Bounded_Set_Iterator<T>::first (void) +ACE_Bounded_Set_Iterator<T>::first () { ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::first"); @@ -1392,7 +1392,7 @@ ACE_Bounded_Set_Iterator<T>::first (void) } template <class T> int -ACE_Bounded_Set_Iterator<T>::done (void) const +ACE_Bounded_Set_Iterator<T>::done () const { ACE_TRACE ("ACE_Bounded_Set_Iterator<T>::done"); @@ -1422,14 +1422,14 @@ ACE_DNode<T>::ACE_DNode (const T &i, ACE_DNode<T> *n, ACE_DNode<T> *p) } template <class T> -ACE_DNode<T>::~ACE_DNode (void) +ACE_DNode<T>::~ACE_DNode () { } // **************************************************************** template <class T> void -ACE_Unbounded_Stack_Iterator<T>::dump (void) const +ACE_Unbounded_Stack_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Stack_Iterator<T>::dump"); @@ -1445,7 +1445,7 @@ ACE_Unbounded_Stack_Iterator<T>::ACE_Unbounded_Stack_Iterator (ACE_Unbounded_Sta } template <class T> int -ACE_Unbounded_Stack_Iterator<T>::advance (void) +ACE_Unbounded_Stack_Iterator<T>::advance () { // ACE_TRACE ("ACE_Unbounded_Stack_Iterator<T>::advance"); this->current_ = this->current_->next_; @@ -1453,7 +1453,7 @@ ACE_Unbounded_Stack_Iterator<T>::advance (void) } template <class T> int -ACE_Unbounded_Stack_Iterator<T>::first (void) +ACE_Unbounded_Stack_Iterator<T>::first () { // ACE_TRACE ("ACE_Unbounded_Stack_Iterator<T>::first"); this->current_ = this->stack_.head_->next_; @@ -1461,7 +1461,7 @@ ACE_Unbounded_Stack_Iterator<T>::first (void) } template <class T> int -ACE_Unbounded_Stack_Iterator<T>::done (void) const +ACE_Unbounded_Stack_Iterator<T>::done () const { ACE_TRACE ("ACE_Unbounded_Stack_Iterator<T>::done"); @@ -1513,7 +1513,7 @@ ACE_Ordered_MultiSet<T>::ACE_Ordered_MultiSet (const ACE_Ordered_MultiSet<T> &us } template <class T> -ACE_Ordered_MultiSet<T>::~ACE_Ordered_MultiSet (void) +ACE_Ordered_MultiSet<T>::~ACE_Ordered_MultiSet () { // ACE_TRACE ("ACE_Ordered_MultiSet<T>::~ACE_Ordered_MultiSet"); @@ -1606,7 +1606,7 @@ ACE_Ordered_MultiSet<T>::find (const T &item, template <class T> void -ACE_Ordered_MultiSet<T>::reset (void) +ACE_Ordered_MultiSet<T>::reset () { ACE_TRACE ("reset"); @@ -1614,7 +1614,7 @@ ACE_Ordered_MultiSet<T>::reset (void) } template <class T> void -ACE_Ordered_MultiSet<T>::dump (void) const +ACE_Ordered_MultiSet<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Ordered_MultiSet<T>::dump"); @@ -1769,7 +1769,7 @@ ACE_Ordered_MultiSet<T>::copy_nodes (const ACE_Ordered_MultiSet<T> &us) } template <class T> void -ACE_Ordered_MultiSet<T>::delete_nodes (void) +ACE_Ordered_MultiSet<T>::delete_nodes () { // iterate through list, deleting nodes for (ACE_DNode<T> *curr = this->head_; @@ -1813,7 +1813,7 @@ ACE_Ordered_MultiSet_Iterator<T>::next (T *&item) const } template <class T> T& -ACE_Ordered_MultiSet_Iterator<T>::operator* (void) +ACE_Ordered_MultiSet_Iterator<T>::operator* () { //ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::operator*"); T *retv = 0; @@ -1849,7 +1849,7 @@ ACE_DLList<T>::insert_head (T *new_item) } template <class T> T * -ACE_DLList<T>::delete_head (void) +ACE_DLList<T>::delete_head () { ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_head (); T *temp2 = (T *) (temp1 ? temp1->item_ : 0); @@ -1861,7 +1861,7 @@ ACE_DLList<T>::delete_head (void) } template <class T> T * -ACE_DLList<T>::delete_tail (void) +ACE_DLList<T>::delete_tail () { ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_tail (); T *temp2 = (T *) (temp1 ? temp1->item_ : 0); diff --git a/ACE/ace/Containers_T.h b/ACE/ace/Containers_T.h index 90a967b6f6b..5cbbca05813 100644 --- a/ACE/ace/Containers_T.h +++ b/ACE/ace/Containers_T.h @@ -103,7 +103,7 @@ public: /** * Deallocate the memory used by the Bounded_Stack. */ - ~ACE_Bounded_Stack (void); + ~ACE_Bounded_Stack (); // = Classic Stack operations. @@ -137,22 +137,22 @@ public: /** * Performs constant time check to determine if the stack is empty. */ - int is_empty (void) const; + int is_empty () const; /// Returns 1 if the container is full, otherwise returns 0. /** * Performs constant time check to determine if the stack is at capacity. */ - int is_full (void) const; + int is_full () const; /// The number of items in the stack. /** * Return the number of items currently in the stack. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -210,7 +210,7 @@ public: /** * Initialize an empty stack. */ - ACE_Fixed_Stack (void); + ACE_Fixed_Stack (); /// The copy constructor (performs initialization). /** @@ -228,7 +228,7 @@ public: /** * Destroy the stack. */ - ~ACE_Fixed_Stack (void); + ~ACE_Fixed_Stack (); // = Classic Stack operations. @@ -262,22 +262,22 @@ public: /** * Performs constant time check to see if stack is empty. */ - int is_empty (void) const; + int is_empty () const; /// Returns 1 if the container is full, otherwise returns 0. /** * Performs constant time check to see if stack is full. */ - int is_full (void) const; + int is_full () const; /// The number of items in the stack. /** * Constant time access to the current size of the stack. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -311,7 +311,7 @@ class ACE_DNode public: /// This isn't necessary, but it keeps some compilers happy. - ~ACE_DNode (void); + ~ACE_DNode (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -399,7 +399,7 @@ public: /** * Destroy the underlying list for the stack. */ - ~ACE_Unbounded_Stack (void); + ~ACE_Unbounded_Stack (); // = Classic Stack operations. @@ -434,13 +434,13 @@ public: /** * Constant time check to see if the stack is empty. */ - int is_empty (void) const; + int is_empty () const; /// Returns 1 if the container is full, otherwise returns 0. /** * Always resturns 0 since the stack is unbounded. */ - int is_full (void) const; + int is_full () const; // = Auxiliary methods (not strictly part of the Stack ADT). @@ -469,17 +469,17 @@ public: /** * Constant time access to the current stack size. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; private: /// Delete all the nodes in the stack. - void delete_all_nodes (void); + void delete_all_nodes (); /// Copy all nodes from {s} to {this}. void copy_all_nodes (const ACE_Unbounded_Stack<T> &s); @@ -514,17 +514,17 @@ public: /// Move forward by one element in the Stack. Returns 0 when all the /// items in the Stack have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the Stack. Returns 0 if the /// Stack is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -560,14 +560,14 @@ public: * @deprecated Return the address of next (current) unvisited item in * the list. 0 if there is no more element available. */ - T *next (void) const; + T *next () const; /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// STL-like iterator dereference operator: returns a reference /// to the node underneath the iterator. - T & operator* (void) const ; + T & operator* () const ; /** * Retasks the iterator to iterate over a new @@ -598,11 +598,11 @@ protected: * @note the head of the ACE_DLList is actually a null entry, so the * first element is actually the 2n'd entry */ - int go_head (void); + int go_head (); /// Move to the last element of the list. Returns 0 if the list is /// empty, else 1. - int go_tail (void); + int go_tail (); /** * Check if we reach the end of the list. Can also be used to get @@ -610,18 +610,18 @@ protected: * current item if there are still elements left , 0 if we run out * of element. */ - T *not_done (void) const ; + T *not_done () const ; /// Advance to the next element in the list. Return the address of the /// next element if there are more, 0 otherwise. - T *do_advance (void); + T *do_advance (); /// Retreat to the previous element in the list. Return the address /// of the previous element if there are more, 0 otherwise. - T *do_retreat (void); + T *do_retreat (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Remember where we are. T *current_; @@ -661,11 +661,11 @@ public: /// Move to the first element in the list. Returns 0 if the /// list is empty, else 1. - int first (void); + int first (); /// Move forward by one element in the list. Returns 0 when all the /// items in the list have been seen, else 1. - int advance (void); + int advance (); /** * Advance the iterator while removing the original item from the @@ -678,19 +678,19 @@ public: // = STL-style iteration methods /// Prefix advance. - ACE_Double_Linked_List_Iterator<T> & operator++ (void); + ACE_Double_Linked_List_Iterator<T> & operator++ (); /// Postfix advance. ACE_Double_Linked_List_Iterator<T> operator++ (int); /// Prefix reverse. - ACE_Double_Linked_List_Iterator<T> & operator-- (void); + ACE_Double_Linked_List_Iterator<T> & operator-- (); /// Postfix reverse. ACE_Double_Linked_List_Iterator<T> operator-- (int); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -729,11 +729,11 @@ public: /// Move to the first element in the list. Returns 0 if the /// list is empty, else 1. - int first (void); + int first (); /// Move forward by one element in the list. Returns 0 when all the /// items in the list have been seen, else 1. - int advance (void); + int advance (); /** * Advance the iterator while removing the original item from the @@ -746,19 +746,19 @@ public: // = STL-style iteration methods /// Prefix advance. - ACE_Double_Linked_List_Reverse_Iterator<T> & operator++ (void); + ACE_Double_Linked_List_Reverse_Iterator<T> & operator++ (); /// Postfix advance. ACE_Double_Linked_List_Reverse_Iterator<T> operator++ (int); /// Prefix reverse. - ACE_Double_Linked_List_Reverse_Iterator<T> & operator-- (void); + ACE_Double_Linked_List_Reverse_Iterator<T> & operator-- (); /// Postfix reverse. ACE_Double_Linked_List_Reverse_Iterator<T> operator-- (int); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -846,7 +846,7 @@ public: /** * Clean up the memory allocated for the nodes of the list. */ - ~ACE_Double_Linked_List (void); + ~ACE_Double_Linked_List (); // = Check boundary conditions. @@ -854,13 +854,13 @@ public: /** * Performs constant time check to determine if the list is empty. */ - int is_empty (void) const; + int is_empty () const; /// The list is unbounded, so this always returns 0. /** * Since the list is unbounded, the method simply returns 0. */ - int is_full (void) const; + int is_full () const; // = Classic queue operations. @@ -884,7 +884,7 @@ public: * internal node's address on success, 0 if the queue was empty. * This method will *not* free the internal node. */ - T* delete_head (void); + T* delete_head (); /// Removes the tail of the list and returns a pointer to that item. /** @@ -892,7 +892,7 @@ public: * internal nodes's address on success, 0 if the queue was * empty. This method will *not* free the internal node. */ - T *delete_tail (void); + T *delete_tail (); // = Additional utility methods. @@ -902,7 +902,7 @@ public: * Notice that since no one is interested in the items within, * This operation will delete all items. */ - void reset (void); + void reset (); /// Get the {slot}th element in the set. Returns -1 if the element /// isn't in the range {0..{size} - 1}, else 0. @@ -916,10 +916,10 @@ public: /** * Constant time call to return the current size of the list. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Use DNode address directly. /** @@ -935,7 +935,7 @@ protected: /** * Removes and deallocates memory for all of the list nodes. */ - void delete_nodes (void); + void delete_nodes (); /// Copy nodes from {rhs} into this list. /** @@ -948,7 +948,7 @@ protected: /** * Initialize the head pointer so that the list has a dummy node. */ - void init_head (void); + void init_head (); ///Constant time insert a new item into the list structure. /** @@ -1052,7 +1052,7 @@ public: * @return Pointer to previously inserted item; 0 if the list is empty, * an error occurred, or the original pointer inserted was 0. */ - T *delete_head (void); + T *delete_head (); /** * Removes the item at the tail of the list and returns its pointer. @@ -1060,7 +1060,7 @@ public: * @return Pointer to previously inserted item; 0 if the list is empty, * an error occurred, or the original pointer inserted was 0. */ - T *delete_tail (void); + T *delete_tail (); //@} /** @@ -1076,7 +1076,7 @@ public: int get (T *&item, size_t slot = 0); /// Delegates to ACE_Double_Linked_List. - void dump (void) const; + void dump () const; /// Delegates to ACE_Double_Linked_List. int remove (ACE_DLList_Node *n); @@ -1107,7 +1107,7 @@ public: delete *p; @endcode */ - ~ACE_DLList (void); + ~ACE_DLList (); }; /** @@ -1142,7 +1142,7 @@ public: // = Iteration methods. /// Move forward by one element in the list. Returns 0 when all the /// items in the list have been seen, else 1. - int advance (void); + int advance (); /// Pass back the {next_item} that hasn't been seen in the list. /// Returns 0 when all items have been seen, else 1. @@ -1153,7 +1153,7 @@ public: * whereas the Double_Linked_List version of next returns the node, this next * returns the contents of the node */ - T *next (void) const; + T *next () const; /** * Removes the current item (i.e., {next}) from the list. @@ -1161,10 +1161,10 @@ public: * directly (defined in its base class) and you will need to * release the element returned by it. */ - int remove (void); + int remove (); /// Delegates to ACE_Double_Linked_List_Iterator. - void dump (void) const; + void dump () const; private: ACE_DLList<T> *list_; @@ -1202,23 +1202,23 @@ public: // = Iteration methods. /// Move forward by one element in the list. Returns 0 when all the /// items in the list have been seen, else 1. - int advance (void); + int advance (); /// Pass back the {next_item} that hasn't been seen in the list. /// Returns 0 when all items have been seen, else 1. int next (T *&); /// @deprecated Delegates to ACE_Double_Linked_List_Iterator. - T *next (void) const; + T *next () const; /// Removes the current item (i.e., {next}) from the list. /// Note that DLList iterators do not support {advance_and_remove} /// directly (defined in its base class) and you will need to /// release the element returned by it. - int remove (void); + int remove (); /// Delegates to ACE_Double_Linked_List_Iterator. - void dump (void) const; + void dump () const; private: ACE_DLList<T> *list_; @@ -1245,14 +1245,14 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the set. Returns 0 if the /// set is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1270,7 +1270,7 @@ protected: size_t iterated_items_; /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Pass back the {next_item} that hasn't been seen in the Set. /// Returns 0 when all items have been seen, else 1. @@ -1298,7 +1298,7 @@ public: int next (T *&next_item); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Remove the item where the itearetor is located at. /// Returns 1 if it removes a item, else 0. @@ -1307,7 +1307,7 @@ public: /// STL-like iterator dereference operator: returns a reference /// to the node underneath the iterator. - T & operator* (void); + T & operator* (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1333,11 +1333,11 @@ public: int next (const T *&next_item); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// STL-like iterator dereference operator: returns a reference /// to the node underneath the iterator. - const T & operator* (void) const ; + const T & operator* () const ; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1391,7 +1391,7 @@ public: /** * Creates an empy set */ - ACE_Fixed_Set (void); + ACE_Fixed_Set (); /// Copy constructor. /** @@ -1409,7 +1409,7 @@ public: /** * Destroys a set. */ - ~ACE_Fixed_Set (void); + ~ACE_Fixed_Set (); // = Check boundary conditions. @@ -1417,13 +1417,13 @@ public: /** * Performs constant time check to determine if a set is empty. */ - int is_empty (void) const; + int is_empty () const; /// Returns 1 if the container is full, otherwise returns 0. /** * Performs a constant time check to see if the set is full. */ - int is_full (void) const; + int is_full () const; // = Classic unordered set operations. @@ -1453,10 +1453,10 @@ public: /** * Returns the current size of the set. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1505,17 +1505,17 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the set. Returns 0 if the /// set is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1584,7 +1584,7 @@ public: * The default constructor initializes the Bounded_Set to a maximum size * specified by the DEFAULT_SIZE. */ - ACE_Bounded_Set (void); + ACE_Bounded_Set (); /// Construct a Bounded_Set with the provided sizeB. /** @@ -1612,7 +1612,7 @@ public: * Clean up the underlying dynamically allocated memory that is used by * the Bounded_Set. */ - ~ACE_Bounded_Set (void); + ~ACE_Bounded_Set (); // = Check boundary conditions. @@ -1621,14 +1621,14 @@ public: * A constant time check is performed to determine if the Bounded_Set is * empty. */ - int is_empty (void) const; + int is_empty () const; /// Returns 1 if the container is full, otherwise returns 0. /** * Performs a constant time check to determine if the Bounded_Set is at * capacity. */ - int is_full (void) const; + int is_full () const; // = Classic unordered set operations. @@ -1661,10 +1661,10 @@ public: /** * Returns a size_t representing the current size of the set. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1713,28 +1713,28 @@ public: /// Repositions the iterator at the first item in the ordered multiset /// Returns 0 if the list is empty else 1. - int first (void); + int first (); /// Repositions the iterator at the last item in the ordered multiset /// Returns 0 if the list is empty else 1. - int last (void); + int last (); /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Move backward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int retreat (void); + int retreat (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Returns a reference to the internal element {this} is pointing to. - T& operator* (void); + T& operator* (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1808,7 +1808,7 @@ public: /** * Delete the nodes of the set. */ - ~ACE_Ordered_MultiSet (void); + ~ACE_Ordered_MultiSet (); /// Assignment operator. /** @@ -1822,13 +1822,13 @@ public: /** * Constant time check to determine if the set is empty. */ - int is_empty (void) const; + int is_empty () const; /// Size of the set. /** * Constant time check to determine the size of the set. */ - size_t size (void) const; + size_t size () const; // = Classic unordered set operations. @@ -1868,10 +1868,10 @@ public: /** * Delete the nodes inside the set. */ - void reset (void); + void reset (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -1900,7 +1900,7 @@ private: ACE_DNode<T> *&new_position) const; /// Delete all the nodes in the Set. - void delete_nodes (void); + void delete_nodes (); /// Copy nodes into this set. void copy_nodes (const ACE_Ordered_MultiSet<T> &); diff --git a/ACE/ace/Containers_T.inl b/ACE/ace/Containers_T.inl index adc0f42cd23..9ef0b04df29 100644 --- a/ACE/ace/Containers_T.inl +++ b/ACE/ace/Containers_T.inl @@ -2,14 +2,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class T> ACE_INLINE int -ACE_Bounded_Stack<T>::is_empty (void) const +ACE_Bounded_Stack<T>::is_empty () const { ACE_TRACE ("ACE_Bounded_Stack<T>::is_empty"); return this->top_ == 0; } template <class T> ACE_INLINE int -ACE_Bounded_Stack<T>::is_full (void) const +ACE_Bounded_Stack<T>::is_full () const { ACE_TRACE ("ACE_Bounded_Stack<T>::is_full"); return this->top_ >= this->size_; @@ -55,7 +55,7 @@ ACE_Bounded_Stack<T>::top (T &item) const } template <class T> ACE_INLINE size_t -ACE_Bounded_Stack<T>::size (void) const +ACE_Bounded_Stack<T>::size () const { return this->size_; } @@ -63,14 +63,14 @@ ACE_Bounded_Stack<T>::size (void) const //---------------------------------------- template <class T, size_t ACE_SIZE> ACE_INLINE int -ACE_Fixed_Stack<T, ACE_SIZE>::is_empty (void) const +ACE_Fixed_Stack<T, ACE_SIZE>::is_empty () const { ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::is_empty"); return this->top_ == 0; } template <class T, size_t ACE_SIZE> ACE_INLINE int -ACE_Fixed_Stack<T, ACE_SIZE>::is_full (void) const +ACE_Fixed_Stack<T, ACE_SIZE>::is_full () const { ACE_TRACE ("ACE_Fixed_Stack<T, ACE_SIZE>::is_full"); return this->top_ >= this->size_; @@ -116,13 +116,13 @@ ACE_Fixed_Stack<T, ACE_SIZE>::top (T &item) const } template <class T, size_t ACE_SIZE> ACE_INLINE size_t -ACE_Fixed_Stack<T, ACE_SIZE>::size (void) const +ACE_Fixed_Stack<T, ACE_SIZE>::size () const { return this->size_; } template <class T> ACE_INLINE int -ACE_Unbounded_Stack<T>::is_empty (void) const +ACE_Unbounded_Stack<T>::is_empty () const { // ACE_TRACE ("ACE_Unbounded_Stack<T>::is_empty"); return this->head_ == this->head_->next_; @@ -142,14 +142,14 @@ ACE_Unbounded_Stack<T>::top (T &item) const } template <class T> ACE_INLINE int -ACE_Unbounded_Stack<T>::is_full (void) const +ACE_Unbounded_Stack<T>::is_full () const { ACE_TRACE ("ACE_Unbounded_Stack<T>::is_full"); return 0; // ??? } template <class T> ACE_INLINE size_t -ACE_Unbounded_Stack<T>::size (void) const +ACE_Unbounded_Stack<T>::size () const { return this->cur_size_; } @@ -160,14 +160,14 @@ ACE_Unbounded_Stack<T>::size (void) const // --- template <class T, size_t ACE_SIZE> ACE_INLINE int -ACE_Fixed_Set<T, ACE_SIZE>::is_empty (void) const +ACE_Fixed_Set<T, ACE_SIZE>::is_empty () const { ACE_TRACE ("ACE_Fixed_Set<T>::is_empty"); return this->cur_size_ == 0; } template <class T, size_t ACE_SIZE> ACE_INLINE int -ACE_Fixed_Set<T, ACE_SIZE>::is_full (void) const +ACE_Fixed_Set<T, ACE_SIZE>::is_full () const { ACE_TRACE ("ACE_Fixed_Set<T, ACE_SIZE>::is_full"); return this->cur_size_ == this->max_size_; @@ -176,14 +176,14 @@ ACE_Fixed_Set<T, ACE_SIZE>::is_full (void) const // --- template <class T> ACE_INLINE int -ACE_Bounded_Set<T>::is_empty (void) const +ACE_Bounded_Set<T>::is_empty () const { ACE_TRACE ("ACE_Bounded_Set<T>::is_empty"); return this->cur_size_ == 0; } template <class T> ACE_INLINE int -ACE_Bounded_Set<T>::is_full (void) const +ACE_Bounded_Set<T>::is_full () const { ACE_TRACE ("ACE_Bounded_Set<T>::is_full"); return this->cur_size_ == this->max_size_; @@ -192,7 +192,7 @@ ACE_Bounded_Set<T>::is_full (void) const // -- template <class T> ACE_INLINE int -ACE_Ordered_MultiSet_Iterator<T>::first (void) +ACE_Ordered_MultiSet_Iterator<T>::first () { ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::first"); current_ = set_.head_; @@ -201,7 +201,7 @@ ACE_Ordered_MultiSet_Iterator<T>::first (void) } template <class T> ACE_INLINE int -ACE_Ordered_MultiSet_Iterator<T>::last (void) +ACE_Ordered_MultiSet_Iterator<T>::last () { ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::last"); current_ = set_.tail_; @@ -210,7 +210,7 @@ ACE_Ordered_MultiSet_Iterator<T>::last (void) } template <class T> ACE_INLINE int -ACE_Ordered_MultiSet_Iterator<T>::advance (void) +ACE_Ordered_MultiSet_Iterator<T>::advance () { ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::advance"); @@ -220,7 +220,7 @@ ACE_Ordered_MultiSet_Iterator<T>::advance (void) } template <class T> ACE_INLINE int -ACE_Ordered_MultiSet_Iterator<T>::retreat (void) +ACE_Ordered_MultiSet_Iterator<T>::retreat () { ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::retreat"); @@ -230,7 +230,7 @@ ACE_Ordered_MultiSet_Iterator<T>::retreat (void) } template <class T> ACE_INLINE int -ACE_Ordered_MultiSet_Iterator<T>::done (void) const +ACE_Ordered_MultiSet_Iterator<T>::done () const { ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::done"); @@ -238,7 +238,7 @@ ACE_Ordered_MultiSet_Iterator<T>::done (void) const } template <class T> ACE_INLINE void -ACE_Ordered_MultiSet_Iterator<T>::dump (void) const +ACE_Ordered_MultiSet_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Ordered_MultiSet_Iterator<T>::dump"); @@ -250,14 +250,14 @@ ACE_Ordered_MultiSet_Iterator<T>::dump (void) const // -- template <class T> ACE_INLINE int -ACE_Ordered_MultiSet<T>::is_empty (void) const +ACE_Ordered_MultiSet<T>::is_empty () const { ACE_TRACE ("ACE_Ordered_MultiSet<T>::is_empty"); return this->cur_size_ > 0 ? 0 : 1; } template <class T> ACE_INLINE size_t -ACE_Ordered_MultiSet<T>::size (void) const +ACE_Ordered_MultiSet<T>::size () const { // ACE_TRACE ("ACE_Ordered_MultiSet<T>::size"); return this->cur_size_; @@ -329,7 +329,7 @@ ACE_DLList<T>::get (T *&item, size_t index) } template <class T> ACE_INLINE void -ACE_DLList<T>::dump (void) const +ACE_DLList<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_DLList_Base::dump (); @@ -359,13 +359,13 @@ ACE_DLList<T>::ACE_DLList (const ACE_DLList<T> &l) } template <class T> ACE_INLINE -ACE_DLList<T>::~ACE_DLList (void) +ACE_DLList<T>::~ACE_DLList () { while (this->delete_head ()) ; } template <class T> ACE_INLINE int -ACE_DLList_Iterator<T>::remove (void) +ACE_DLList_Iterator<T>::remove () { ACE_DLList_Node *temp = this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next (); this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance (); @@ -397,20 +397,20 @@ ACE_DLList_Iterator<T>::next (T *&ptr) } template <class T> ACE_INLINE T * -ACE_DLList_Iterator<T>::next (void) const +ACE_DLList_Iterator<T>::next () const { ACE_DLList_Node *temp = ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::next (); return (T *) (temp ? temp->item_ : 0); } template <class T> ACE_INLINE int -ACE_DLList_Iterator<T>::advance (void) +ACE_DLList_Iterator<T>::advance () { return this->ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::advance (); } template <class T> ACE_INLINE void -ACE_DLList_Iterator<T>::dump (void) const +ACE_DLList_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_Double_Linked_List_Iterator <ACE_DLList_Node>::dump (); @@ -419,7 +419,7 @@ ACE_DLList_Iterator<T>::dump (void) const template <class T> ACE_INLINE int -ACE_DLList_Reverse_Iterator<T>::remove (void) +ACE_DLList_Reverse_Iterator<T>::remove () { ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next (); this->ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance (); @@ -441,7 +441,7 @@ ACE_DLList_Reverse_Iterator<T>::reset (ACE_DLList<T> &l) } template <class T> ACE_INLINE int -ACE_DLList_Reverse_Iterator<T>::advance (void) +ACE_DLList_Reverse_Iterator<T>::advance () { return ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::advance (); } @@ -458,7 +458,7 @@ ACE_DLList_Reverse_Iterator<T>::next (T *&ptr) } template <class T> ACE_INLINE T * -ACE_DLList_Reverse_Iterator<T>::next (void) const +ACE_DLList_Reverse_Iterator<T>::next () const { ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::next (); return (T *) (temp ? temp->item_ : 0); @@ -466,7 +466,7 @@ ACE_DLList_Reverse_Iterator<T>::next (void) const template <class T> ACE_INLINE void -ACE_DLList_Reverse_Iterator<T>::dump (void) const +ACE_DLList_Reverse_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_Double_Linked_List_Reverse_Iterator <ACE_DLList_Node>::dump (); diff --git a/ACE/ace/Copy_Disabled.h b/ACE/ace/Copy_Disabled.h index de053516f3a..264dec106cb 100644 --- a/ACE/ace/Copy_Disabled.h +++ b/ACE/ace/Copy_Disabled.h @@ -47,7 +47,7 @@ class ACE_Export ACE_Copy_Disabled { public: /// Default constructor - ACE_Copy_Disabled (void); + ACE_Copy_Disabled (); private: ACE_Copy_Disabled (const ACE_Copy_Disabled &) = delete; diff --git a/ACE/ace/DLL.h b/ACE/ace/DLL.h index c646964855f..0ca0b5a806e 100644 --- a/ACE/ace/DLL.h +++ b/ACE/ace/DLL.h @@ -131,14 +131,14 @@ public: bool close_handle_on_destruction = true); /// Call to close the DLL object. - int close (void); + int close (); /** * Called when the DLL object is destroyed -- invokes close() if the * @a close_handle_on_destruction flag was set to non-zero in the * constructor or open() method. */ - ~ACE_DLL (void); + ~ACE_DLL (); /** * Look up a named symbol in the DLL. DLL must be successfully opened @@ -155,7 +155,7 @@ public: /// Returns a pointer to a string explaining that an error occurred. You /// will need to consult the error log for the actual error string /// returned by the OS. - ACE_TCHAR *error (void) const; + ACE_TCHAR *error () const; /** * Return the handle to the caller. If @a become_owner is true then diff --git a/ACE/ace/Dynamic_Service_Base.h b/ACE/ace/Dynamic_Service_Base.h index 3d46492031b..308290e5fdd 100644 --- a/ACE/ace/Dynamic_Service_Base.h +++ b/ACE/ace/Dynamic_Service_Base.h @@ -37,7 +37,7 @@ class ACE_Export ACE_Dynamic_Service_Base { public: /// Dump the current static of the object - void dump (void) const; + void dump () const; protected: /// Perform the default repo search, but optionally skip searching the global @@ -49,8 +49,8 @@ protected: bool no_global = false); /// No need to create, or assign instances of this class - ACE_Dynamic_Service_Base (void); - ~ACE_Dynamic_Service_Base (void); + ACE_Dynamic_Service_Base (); + ~ACE_Dynamic_Service_Base (); const ACE_Dynamic_Service_Base& operator= (const ACE_Dynamic_Service_Base&); private: diff --git a/ACE/ace/Event.cpp b/ACE/ace/Event.cpp index 20fe0730644..01918ec80e1 100644 --- a/ACE/ace/Event.cpp +++ b/ACE/ace/Event.cpp @@ -38,7 +38,7 @@ ACE_Event_T<TIME_POLICY>::ACE_Event_T (int manual_reset, } template <class TIME_POLICY> -ACE_Event_T<TIME_POLICY>::~ACE_Event_T (void) +ACE_Event_T<TIME_POLICY>::~ACE_Event_T () { } diff --git a/ACE/ace/Event.h b/ACE/ace/Event.h index e8c9db91faf..d0ebcb0c160 100644 --- a/ACE/ace/Event.h +++ b/ACE/ace/Event.h @@ -49,11 +49,11 @@ public: LPSECURITY_ATTRIBUTES sa = 0); /// Implicitly destroy the event variable. - virtual ~ACE_Event_T (void); + virtual ~ACE_Event_T (); /// Get the current time of day according to the queue's TIME_POLICY. /// Allows users to initialize timeout values using correct time policy. - ACE_Time_Value_T<TIME_POLICY> gettimeofday (void) const; + ACE_Time_Value_T<TIME_POLICY> gettimeofday () const; /// Allows applications to control how the event gets the time /// of day. diff --git a/ACE/ace/Event.inl b/ACE/ace/Event.inl index b8a688be71d..b369cd29649 100644 --- a/ACE/ace/Event.inl +++ b/ACE/ace/Event.inl @@ -3,7 +3,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class TIME_POLICY> ACE_Time_Value_T<TIME_POLICY> -ACE_Event_T<TIME_POLICY>::gettimeofday (void) const +ACE_Event_T<TIME_POLICY>::gettimeofday () const { return this->time_policy_ (); } diff --git a/ACE/ace/Event_Base.h b/ACE/ace/Event_Base.h index a158c5e67fe..aaef456772b 100644 --- a/ACE/ace/Event_Base.h +++ b/ACE/ace/Event_Base.h @@ -40,17 +40,17 @@ class ACE_Export ACE_Event_Base { public: /// Implicitly destroy the event variable. - virtual ~ACE_Event_Base (void); + virtual ~ACE_Event_Base (); /** * Explicitly destroy the event variable. Note that only one thread * should call this method since it doesn't protect against race * conditions. */ - int remove (void); + int remove (); /// Underlying handle to event. - ACE_event_t handle (void) const; + ACE_event_t handle () const; /** * Set the underlying handle to event. Note that this method assumes @@ -70,7 +70,7 @@ public: * sleep till the event becomes signaled * event resets wait() completes. */ - int wait (void); + int wait (); /// Same as wait() above, but this one can be timed /// @a abstime is absolute time-of-day if if @a use_absolute_time @@ -87,7 +87,7 @@ public: * if thread(s) are waiting, wake up one waiting thread and * reset event */ - int signal (void); + int signal (); /** * if MANUAL reset @@ -97,13 +97,13 @@ public: * wakeup one waiting thread (if present) and * reset event */ - int pulse (void); + int pulse (); /// Set to nonsignaled state. - int reset (void); + int reset (); /// 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/Event_Base.inl b/ACE/ace/Event_Base.inl index fa8cf909e27..dc38a38f45c 100644 --- a/ACE/ace/Event_Base.inl +++ b/ACE/ace/Event_Base.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_event_t -ACE_Event_Base::handle (void) const +ACE_Event_Base::handle () const { return this->handle_; } diff --git a/ACE/ace/Event_Handler.h b/ACE/ace/Event_Handler.h index 6d70762a04a..ae23e7e82a4 100644 --- a/ACE/ace/Event_Handler.h +++ b/ACE/ace/Event_Handler.h @@ -83,10 +83,10 @@ public: }; /// Destructor is virtual to enable proper cleanup. - virtual ~ACE_Event_Handler (void); + virtual ~ACE_Event_Handler (); /// Get the I/O handle. - virtual ACE_HANDLE get_handle (void) const; + virtual ACE_HANDLE get_handle () const; /// Set the I/O handle. virtual void set_handle (ACE_HANDLE); @@ -96,7 +96,7 @@ public: /// Get the priority of the Event_Handler. /// @note Priorities run from MIN_PRIORITY (which is the "lowest priority") /// to MAX_PRIORITY (which is the "highest priority"). - virtual int priority (void) const; + virtual int priority () const; /// Set the priority of the Event_Handler. virtual void priority (int priority); @@ -156,7 +156,7 @@ public: * @note This method has an affect only when used with the * ACE_Dev_Poll_Reactor (and then, only on Linux) or the ACE_TP_Reactor. */ - virtual int resume_handler (void); + virtual int resume_handler (); virtual int handle_qos (ACE_HANDLE = ACE_INVALID_HANDLE); virtual int handle_group_qos (ACE_HANDLE = ACE_INVALID_HANDLE); @@ -166,10 +166,10 @@ public: virtual void reactor (ACE_Reactor *reactor); /// Get the event demultiplexors. - virtual ACE_Reactor *reactor (void) const; + virtual ACE_Reactor *reactor () const; /// Get only the reactor's timer related interface. - virtual ACE_Reactor_Timer_Interface *reactor_timer_interface (void) const; + virtual ACE_Reactor_Timer_Interface *reactor_timer_interface () const; /** * Used to read from non-socket ACE_HANDLEs in our own thread to @@ -208,7 +208,7 @@ public: * * @return Current reference count. */ - virtual Reference_Count add_reference (void); + virtual Reference_Count add_reference (); /// Decrement reference count on the handler. /** @@ -219,7 +219,7 @@ public: * * @return Current reference count. */ - virtual Reference_Count remove_reference (void); + virtual Reference_Count remove_reference (); /** * @class Policy @@ -232,7 +232,7 @@ public: public: /// Virtual destructor. - virtual ~Policy (void); + virtual ~Policy (); }; /** @@ -263,7 +263,7 @@ public: }; /// Current Reference_Counting_Policy. - Value value (void) const; + Value value () const; /// Update Reference_Counting_Policy. void value (Value value); @@ -277,7 +277,7 @@ public: }; /// Current Reference_Counting_Policy. - Reference_Counting_Policy &reference_counting_policy (void); + Reference_Counting_Policy &reference_counting_policy (); protected: /// Force ACE_Event_Handler to be an abstract base class. @@ -313,7 +313,7 @@ class ACE_Export ACE_Event_Handler_var { public: /// Default constructor. - ACE_Event_Handler_var (void); + ACE_Event_Handler_var (); /// Construct with a handler. ACE_Event_Handler_var (ACE_Event_Handler *p); @@ -322,7 +322,7 @@ public: ACE_Event_Handler_var (const ACE_Event_Handler_var &b); /// Destructor. - ~ACE_Event_Handler_var (void); + ~ACE_Event_Handler_var (); /// Assignment to a handler. ACE_Event_Handler_var &operator= (ACE_Event_Handler *p); @@ -334,10 +334,10 @@ public: ACE_Event_Handler *operator-> () const; /// Access the handler. - ACE_Event_Handler *handler (void) const; + ACE_Event_Handler *handler () const; /// Release the handler. - ACE_Event_Handler *release (void); + ACE_Event_Handler *release (); /// Reset the handler. void reset (ACE_Event_Handler *p = 0); @@ -389,13 +389,13 @@ namespace ACE class ACE_Export ACE_Notification_Buffer { public: - ACE_Notification_Buffer (void); + ACE_Notification_Buffer (); ACE_Notification_Buffer (ACE_Event_Handler *eh, ACE_Reactor_Mask mask); /// Default destructor. - ~ACE_Notification_Buffer (void) = default; + ~ACE_Notification_Buffer () = default; /// Pointer to the Event_Handler that will be dispatched /// by the main event loop. diff --git a/ACE/ace/Framework_Component.h b/ACE/ace/Framework_Component.h index 8ffba2d5fac..20882ebe79c 100644 --- a/ACE/ace/Framework_Component.h +++ b/ACE/ace/Framework_Component.h @@ -67,11 +67,11 @@ public: const ACE_TCHAR *name = 0); /// Close the contained singleton. - virtual void close_singleton (void) = 0; + virtual void close_singleton () = 0; protected: /// Destructor. - virtual ~ACE_Framework_Component (void); + virtual ~ACE_Framework_Component (); private: /// Pointer to the actual component. @@ -106,21 +106,21 @@ public: /// Close down the repository and free up dynamically allocated /// resources. - ~ACE_Framework_Repository (void); + ~ACE_Framework_Repository (); /// Initialize the repository. int open (int size = DEFAULT_SIZE); /// Close down the repository and free up dynamically allocated /// resources, also called by dtor. - int close (void); + int close (); /// Get pointer to a process-wide ACE_Framework_Repository. static ACE_Framework_Repository *instance (int size = ACE_Framework_Repository::DEFAULT_SIZE); /// Delete the dynamically allocated Singleton. - static void close_singleton (void); + static void close_singleton (); // = Search structure operations (all acquire locks as necessary). @@ -136,13 +136,13 @@ public: int remove_dll_components (const ACE_TCHAR *dll_name); /// Return the current size of the repository. - int current_size (void) const; + int current_size () const; /// Return the total size of the repository. - int total_size (void) const; + int total_size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -157,7 +157,7 @@ private: /// Compact component_vector_ after components have been removed__maintains /// order. - void compact (void); + void compact (); private: /// Contains all the framework components. diff --git a/ACE/ace/Framework_Component.inl b/ACE/ace/Framework_Component.inl index e5d25bb2fe8..0ac8b7faa6a 100644 --- a/ACE/ace/Framework_Component.inl +++ b/ACE/ace/Framework_Component.inl @@ -18,7 +18,7 @@ ACE_Framework_Component::ACE_Framework_Component (void *_this, /***************************************************************/ ACE_INLINE int -ACE_Framework_Repository::current_size (void) const +ACE_Framework_Repository::current_size () const { ACE_TRACE ("ACE_Framework_Repository::current_size"); ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, const_cast <ACE_SYNCH_MUTEX&>(this->lock_), -1); @@ -26,7 +26,7 @@ ACE_Framework_Repository::current_size (void) const } ACE_INLINE int -ACE_Framework_Repository::total_size (void) const +ACE_Framework_Repository::total_size () const { ACE_TRACE ("ACE_Framework_Repository::total_size"); ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, const_cast <ACE_SYNCH_MUTEX&>(this->lock_), -1); diff --git a/ACE/ace/Framework_Component_T.cpp b/ACE/ace/Framework_Component_T.cpp index abefe8325b9..1c503d5dd4e 100644 --- a/ACE/ace/Framework_Component_T.cpp +++ b/ACE/ace/Framework_Component_T.cpp @@ -17,7 +17,7 @@ ACE_Framework_Component_T<Concrete>::ACE_Framework_Component_T (Concrete *concre } template <class Concrete> -ACE_Framework_Component_T<Concrete>::~ACE_Framework_Component_T (void) +ACE_Framework_Component_T<Concrete>::~ACE_Framework_Component_T () { ACE_TRACE ("ACE_Framework_Component_T<Concrete>::~ACE_Framework_Component_T"); Concrete::close_singleton (); @@ -26,7 +26,7 @@ ACE_Framework_Component_T<Concrete>::~ACE_Framework_Component_T (void) ACE_ALLOC_HOOK_DEFINE_Tt(ACE_Framework_Component_T) template <class Concrete> void -ACE_Framework_Component_T<Concrete>::close_singleton (void) +ACE_Framework_Component_T<Concrete>::close_singleton () { ACE_TRACE ("ACE_Framework_Component_T<Concrete>::close_singleton"); Concrete::close_singleton (); diff --git a/ACE/ace/Framework_Component_T.h b/ACE/ace/Framework_Component_T.h index 5d5c3995586..a4e7d4ee356 100644 --- a/ACE/ace/Framework_Component_T.h +++ b/ACE/ace/Framework_Component_T.h @@ -40,10 +40,10 @@ public: ACE_Framework_Component_T (Concrete *concrete); /// Destructor. - ~ACE_Framework_Component_T (void); + ~ACE_Framework_Component_T (); /// Close the contained singleton. - void close_singleton (void); + void close_singleton (); ACE_ALLOC_HOOK_DECLARE; }; diff --git a/ACE/ace/Free_List.cpp b/ACE/ace/Free_List.cpp index 36eed6d47f4..e9e9c483fe5 100644 --- a/ACE/ace/Free_List.cpp +++ b/ACE/ace/Free_List.cpp @@ -15,7 +15,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class T> -ACE_Free_List<T>::~ACE_Free_List (void) +ACE_Free_List<T>::~ACE_Free_List () { } @@ -42,7 +42,7 @@ ACE_Locked_Free_List<T, ACE_LOCK>::ACE_Locked_Free_List (int mode, // Destructor - removes all the elements from the free_list template <class T, class ACE_LOCK> -ACE_Locked_Free_List<T, ACE_LOCK>::~ACE_Locked_Free_List (void) +ACE_Locked_Free_List<T, ACE_LOCK>::~ACE_Locked_Free_List () { if (this->mode_ != ACE_PURE_FREE_LIST) while (this->free_list_ != 0) @@ -79,7 +79,7 @@ ACE_Locked_Free_List<T, ACE_LOCK>::add (T *element) // water mark. template <class T, class ACE_LOCK> T * -ACE_Locked_Free_List<T, ACE_LOCK>::remove (void) +ACE_Locked_Free_List<T, ACE_LOCK>::remove () { ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0)); @@ -103,7 +103,7 @@ ACE_Locked_Free_List<T, ACE_LOCK>::remove (void) // Returns the current size of the free list template <class T, class ACE_LOCK> size_t -ACE_Locked_Free_List<T, ACE_LOCK>::size (void) +ACE_Locked_Free_List<T, ACE_LOCK>::size () { return this->size_; } diff --git a/ACE/ace/Free_List.h b/ACE/ace/Free_List.h index 38ca93100e6..7f661d41db2 100644 --- a/ACE/ace/Free_List.h +++ b/ACE/ace/Free_List.h @@ -36,7 +36,7 @@ class ACE_Free_List { public: /// Destructor - removes all the elements from the free_list. - virtual ~ACE_Free_List (void); + virtual ~ACE_Free_List (); /// Inserts an element onto the free list (if it isn't past the high /// water mark). @@ -44,10 +44,10 @@ public: /// Takes a element off the freelist and returns it. It creates /// <inc> new elements if the size is at or below the low water mark. - virtual T *remove (void) = 0; + virtual T *remove () = 0; /// Returns the current size of the free list. - virtual size_t size (void) = 0; + virtual size_t size () = 0; /// Resizes the free list to @a newsize. virtual void resize (size_t newsize) = 0; @@ -82,7 +82,7 @@ public: size_t inc = ACE_DEFAULT_FREE_LIST_INC); /// Destructor - removes all the elements from the free_list. - virtual ~ACE_Locked_Free_List (void); + virtual ~ACE_Locked_Free_List (); /// Inserts an element onto the free list (if it isn't past the high /// water mark). @@ -90,10 +90,10 @@ public: /// Takes a element off the freelist and returns it. It creates /// <inc> new elements if the size is at or below the low water mark. - virtual T *remove (void); + virtual T *remove (); /// Returns the current size of the free list. - virtual size_t size (void); + virtual size_t size (); /// Resizes the free list to @a newsize. virtual void resize (size_t newsize); diff --git a/ACE/ace/Functor.h b/ACE/ace/Functor.h index 8920966639d..8a88dce9312 100644 --- a/ACE/ace/Functor.h +++ b/ACE/ace/Functor.h @@ -58,10 +58,10 @@ class ACE_Export ACE_Command_Base { public: /// Default constructor. - ACE_Command_Base (void); + ACE_Command_Base (); /// Virtual destructor. - virtual ~ACE_Command_Base (void); + virtual ~ACE_Command_Base (); /** * Invokes the method encapsulated by the command, passing along the diff --git a/ACE/ace/Functor.inl b/ACE/ace/Functor.inl index d50490d9f2d..c7d170c2e67 100644 --- a/ACE/ace/Functor.inl +++ b/ACE/ace/Functor.inl @@ -34,7 +34,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL // Default constructor. ACE_INLINE -ACE_Command_Base::ACE_Command_Base (void) +ACE_Command_Base::ACE_Command_Base () { } diff --git a/ACE/ace/Functor_T.cpp b/ACE/ace/Functor_T.cpp index 9b99c5029ee..e71a64fb258 100644 --- a/ACE/ace/Functor_T.cpp +++ b/ACE/ace/Functor_T.cpp @@ -34,7 +34,7 @@ ACE_Command_Callback<RECEIVER, ACTION>::ACE_Command_Callback (RECEIVER &recvr, } template <class RECEIVER, class ACTION> -ACE_Command_Callback<RECEIVER, ACTION>::~ACE_Command_Callback (void) +ACE_Command_Callback<RECEIVER, ACTION>::~ACE_Command_Callback () { } diff --git a/ACE/ace/Functor_T.h b/ACE/ace/Functor_T.h index f89b683d567..c3b6deb2bb1 100644 --- a/ACE/ace/Functor_T.h +++ b/ACE/ace/Functor_T.h @@ -64,7 +64,7 @@ public: ACE_Command_Callback (RECEIVER &recvr, ACTION action); /// Virtual destructor. - virtual ~ACE_Command_Callback (void); + virtual ~ACE_Command_Callback (); /// Invokes the method @c action_ from the object @c receiver_. virtual int execute (void *arg = 0); @@ -89,14 +89,14 @@ template <class RECEIVER> class ACE_Member_Function_Command : public ACE_Command_Base { public: - typedef void (RECEIVER::*PTMF)(void); + typedef void (RECEIVER::*PTMF)(); /// Con Constructor: sets the <receiver_> of the Command to @a recvr, and the /// <action_> of the Command to <action>. ACE_Member_Function_Command (RECEIVER &recvr, PTMF ptmf); /// Virtual destructor. - virtual ~ACE_Member_Function_Command (void); + virtual ~ACE_Member_Function_Command (); /// Invokes the method <action_> from the object <receiver_>. The /// parameter is ignored diff --git a/ACE/ace/Functor_T.inl b/ACE/ace/Functor_T.inl index 415a0090b42..8a4d1d01290 100644 --- a/ACE/ace/Functor_T.inl +++ b/ACE/ace/Functor_T.inl @@ -11,7 +11,7 @@ ACE_Member_Function_Command (RECEIVER &recvr, PTMF ptmf) template<class RECEIVER> ACE_INLINE ACE_Member_Function_Command<RECEIVER>:: -~ACE_Member_Function_Command (void) +~ACE_Member_Function_Command () { } diff --git a/ACE/ace/Guard_T.cpp b/ACE/ace/Guard_T.cpp index dd4f9a2b967..aa997fd4029 100644 --- a/ACE/ace/Guard_T.cpp +++ b/ACE/ace/Guard_T.cpp @@ -23,7 +23,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL // ACE_ALLOC_HOOK_DEFINE(ACE_Guard) template <class ACE_LOCK> void -ACE_Guard<ACE_LOCK>::dump (void) const +ACE_Guard<ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Guard<ACE_LOCK>::dump"); @@ -38,7 +38,7 @@ ACE_Guard<ACE_LOCK>::dump (void) const // ACE_ALLOC_HOOK_DEFINE(ACE_Write_Guard) template <class ACE_LOCK> void -ACE_Write_Guard<ACE_LOCK>::dump (void) const +ACE_Write_Guard<ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Write_Guard<ACE_LOCK>::dump"); @@ -49,7 +49,7 @@ ACE_Write_Guard<ACE_LOCK>::dump (void) const // ACE_ALLOC_HOOK_DEFINE(ACE_Read_Guard) template <class ACE_LOCK> void -ACE_Read_Guard<ACE_LOCK>::dump (void) const +ACE_Read_Guard<ACE_LOCK>::dump () const { // ACE_TRACE ("ACE_Read_Guard<ACE_LOCK>::dump"); ACE_Guard<ACE_LOCK>::dump (); diff --git a/ACE/ace/Guard_T.h b/ACE/ace/Guard_T.h index 03fa8dba9bf..b90de0bced4 100644 --- a/ACE/ace/Guard_T.h +++ b/ACE/ace/Guard_T.h @@ -80,33 +80,33 @@ public: ACE_Guard (ACE_LOCK &l, bool block, int become_owner); /// Implicitly release the lock. - ~ACE_Guard (void); + ~ACE_Guard (); // = Lock accessors. /// Explicitly acquire the lock. - int acquire (void); + int acquire (); /// Conditionally acquire the lock (i.e., won't block). - int tryacquire (void); + int tryacquire (); /// Explicitly release the lock, but only if it is held! - int release (void); + int release (); /// Relinquish ownership of the lock so that it is not released /// implicitly in the destructor. - void disown (void); + void disown (); // = Utility methods. /// true if locked, false if couldn't acquire the lock /// (errno will contain the reason for this). - bool locked (void) const; + bool locked () const; /// Explicitly remove the lock. - int remove (void); + int remove (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. @@ -152,21 +152,21 @@ public: // = Lock accessors. /// Explicitly acquire the write lock. - int acquire_write (void); + int acquire_write (); /// Explicitly acquire the write lock. - int acquire (void); + int acquire (); /// Conditionally acquire the write lock (i.e., won't block). - int tryacquire_write (void); + int tryacquire_write (); /// Conditionally acquire the write lock (i.e., won't block). - int tryacquire (void); + int tryacquire (); // = Utility methods. /// Dump the state of an object. - void dump (void) const; + void dump () const; // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. @@ -196,21 +196,21 @@ public: // = Lock accessors. /// Explicitly acquire the read lock. - int acquire_read (void); + int acquire_read (); /// Explicitly acquire the read lock. - int acquire (void); + int acquire (); /// Conditionally acquire the read lock (i.e., won't block). - int tryacquire_read (void); + int tryacquire_read (); /// Conditionally acquire the read lock (i.e., won't block). - int tryacquire (void); + int tryacquire (); // = Utility methods. /// Dump the state of an object. - void dump (void) const; + void dump () const; // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. @@ -242,36 +242,36 @@ public: ACE_TSS_Guard (ACE_LOCK &lock, bool block = true); /// Implicitly release the thread-specific lock. - ~ACE_TSS_Guard (void); + ~ACE_TSS_Guard (); // = Lock accessors. /// Explicitly acquire the thread-specific lock. - int acquire (void); + int acquire (); /// Conditionally acquire the thread-specific lock (i.e., won't /// block). - int tryacquire (void); + int tryacquire (); /// Explicitly release the thread-specific lock. - int release (void); + int release (); // = Utility methods. /// Explicitly release the thread-specific lock. - int remove (void); + int remove (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Helper, meant for subclass only. - ACE_TSS_Guard (void); + ACE_TSS_Guard (); /// Initialize the key. - void init_key (void); + void init_key (); /// Called when thread exits to clean up the lock. static void cleanup (void *ptr); @@ -306,21 +306,21 @@ public: // = Lock accessors. /// Explicitly acquire the thread-specific write lock. - int acquire_write (void); + int acquire_write (); /// Explicitly acquire the thread-specific write lock. - int acquire (void); + int acquire (); /// Conditionally acquire the thread-specific write lock (i.e., won't block). - int tryacquire_write (void); + int tryacquire_write (); /// Conditionally acquire the thread-specific write lock (i.e., won't block). - int tryacquire (void); + int tryacquire (); // = Utility methods. /// Dump the state of an object. - void dump (void) const; + void dump () const; // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. @@ -348,22 +348,22 @@ public: // = Lock accessors. /// Explicitly acquire the thread-specific read lock. - int acquire_read (void); + int acquire_read (); /// Explicitly acquire the thread-specific read lock. - int acquire (void); + int acquire (); /// Conditionally acquire the thread-specific read lock (i.e., won't /// block). - int tryacquire_read (void); + int tryacquire_read (); /// Conditionally acquire the thread-specific read lock (i.e., won't /// block). - int tryacquire (void); + int tryacquire (); // = Utility methods. /// Dump the state of an object. - void dump (void) const; + void dump () const; // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. diff --git a/ACE/ace/Guard_T.inl b/ACE/ace/Guard_T.inl index 02d6989cdc0..7135fc32cb0 100644 --- a/ACE/ace/Guard_T.inl +++ b/ACE/ace/Guard_T.inl @@ -6,19 +6,19 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class ACE_LOCK> ACE_INLINE int -ACE_Guard<ACE_LOCK>::acquire (void) +ACE_Guard<ACE_LOCK>::acquire () { return this->owner_ = this->lock_->acquire (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Guard<ACE_LOCK>::tryacquire (void) +ACE_Guard<ACE_LOCK>::tryacquire () { return this->owner_ = this->lock_->tryacquire (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Guard<ACE_LOCK>::release (void) +ACE_Guard<ACE_LOCK>::release () { if (this->owner_ == -1) return -1; @@ -59,25 +59,25 @@ ACE_Guard<ACE_LOCK>::ACE_Guard (ACE_LOCK &l, bool /* block */, int become_owner) // lock. template <class ACE_LOCK> ACE_INLINE -ACE_Guard<ACE_LOCK>::~ACE_Guard (void) +ACE_Guard<ACE_LOCK>::~ACE_Guard () { this->release (); } template <class ACE_LOCK> ACE_INLINE bool -ACE_Guard<ACE_LOCK>::locked (void) const +ACE_Guard<ACE_LOCK>::locked () const { return this->owner_ != -1; } template <class ACE_LOCK> ACE_INLINE int -ACE_Guard<ACE_LOCK>::remove (void) +ACE_Guard<ACE_LOCK>::remove () { return this->lock_->remove (); } template <class ACE_LOCK> ACE_INLINE void -ACE_Guard<ACE_LOCK>::disown (void) +ACE_Guard<ACE_LOCK>::disown () { this->owner_ = -1; } @@ -90,25 +90,25 @@ ACE_Write_Guard<ACE_LOCK>::ACE_Write_Guard (ACE_LOCK &m) } template <class ACE_LOCK> ACE_INLINE int -ACE_Write_Guard<ACE_LOCK>::acquire_write (void) +ACE_Write_Guard<ACE_LOCK>::acquire_write () { return this->owner_ = this->lock_->acquire_write (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Write_Guard<ACE_LOCK>::acquire (void) +ACE_Write_Guard<ACE_LOCK>::acquire () { return this->owner_ = this->lock_->acquire_write (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Write_Guard<ACE_LOCK>::tryacquire_write (void) +ACE_Write_Guard<ACE_LOCK>::tryacquire_write () { return this->owner_ = this->lock_->tryacquire_write (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Write_Guard<ACE_LOCK>::tryacquire (void) +ACE_Write_Guard<ACE_LOCK>::tryacquire () { return this->owner_ = this->lock_->tryacquire_write (); } @@ -125,25 +125,25 @@ ACE_Write_Guard<ACE_LOCK>::ACE_Write_Guard (ACE_LOCK &m, } template <class ACE_LOCK> ACE_INLINE int -ACE_Read_Guard<ACE_LOCK>::acquire_read (void) +ACE_Read_Guard<ACE_LOCK>::acquire_read () { return this->owner_ = this->lock_->acquire_read (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Read_Guard<ACE_LOCK>::acquire (void) +ACE_Read_Guard<ACE_LOCK>::acquire () { return this->owner_ = this->lock_->acquire_read (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Read_Guard<ACE_LOCK>::tryacquire_read (void) +ACE_Read_Guard<ACE_LOCK>::tryacquire_read () { return this->owner_ = this->lock_->tryacquire_read (); } template <class ACE_LOCK> ACE_INLINE int -ACE_Read_Guard<ACE_LOCK>::tryacquire (void) +ACE_Read_Guard<ACE_LOCK>::tryacquire () { return this->owner_ = this->lock_->tryacquire_read (); } diff --git a/ACE/ace/Hash_Map_Manager_T.cpp b/ACE/ace/Hash_Map_Manager_T.cpp index 604cab1207a..579b7784b56 100644 --- a/ACE/ace/Hash_Map_Manager_T.cpp +++ b/ACE/ace/Hash_Map_Manager_T.cpp @@ -54,7 +54,7 @@ ACE_Hash_Map_Entry<EXT_ID, INT_ID>::ACE_Hash_Map_Entry (const EXT_ID &ext_id, } template <class EXT_ID, class INT_ID> -ACE_Hash_Map_Entry<EXT_ID, INT_ID>::~ACE_Hash_Map_Entry (void) +ACE_Hash_Map_Entry<EXT_ID, INT_ID>::~ACE_Hash_Map_Entry () { } @@ -83,7 +83,7 @@ ACE_Hash_Map_Entry<EXT_ID, INT_ID>::item () const } template <class EXT_ID, class INT_ID> void -ACE_Hash_Map_Entry<EXT_ID, INT_ID>::dump (void) const +ACE_Hash_Map_Entry<EXT_ID, INT_ID>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -94,7 +94,7 @@ ACE_Hash_Map_Entry<EXT_ID, INT_ID>::dump (void) const } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> void -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -162,7 +162,7 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::open } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close_i (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close_i () { // Protect against "double-deletion" in case the destructor also // gets called. @@ -197,7 +197,7 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::unbind_all_i (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::unbind_all_i () { // Iterate through the entire map calling the destuctor of each // <ACE_Hash_Map_Entry>. @@ -398,7 +398,7 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rebin // ------------------------------------------------------------ template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> void -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i (void) const +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i () const { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i"); @@ -409,7 +409,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i (void) +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i () { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i"); @@ -439,7 +439,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i (void) +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i () { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i"); @@ -470,7 +470,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: // ------------------------------------------------------------ template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> void -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i (void) const +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i () const { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump_i"); @@ -481,7 +481,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i (void) +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i"); @@ -511,7 +511,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i (void) +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i"); diff --git a/ACE/ace/Hash_Map_Manager_T.h b/ACE/ace/Hash_Map_Manager_T.h index 561a7273c1f..755283eb302 100644 --- a/ACE/ace/Hash_Map_Manager_T.h +++ b/ACE/ace/Hash_Map_Manager_T.h @@ -45,19 +45,19 @@ public: ACE_Hash_Map_Entry<EXT_ID, INT_ID> *prev); /// Destructor. - ~ACE_Hash_Map_Entry (void); + ~ACE_Hash_Map_Entry (); /// Key accessor. - EXT_ID& key (void); + EXT_ID& key (); /// Read-only key accessor. - const EXT_ID& key (void) const; + const EXT_ID& key () const; /// Item accessor. - INT_ID& item (void); + INT_ID& item (); /// Read-only item accessor. - const INT_ID& item (void) const; + const INT_ID& item () const; /// Key used to look up an entry. /// @deprecated Use key() @@ -74,7 +74,7 @@ public: ACE_Hash_Map_Entry<EXT_ID, INT_ID> *prev_; /// Dump the state of an object. - void dump (void) const; + void dump () const; }; // Forward decl. @@ -223,13 +223,13 @@ public: /// Close down the ACE_Hash_Map_Manager_Ex and release dynamically allocated /// resources. - int close (void); + int close (); /// Removes all the entries in the ACE_Hash_Map_Manager_Ex. - int unbind_all (void); + int unbind_all (); /// Cleanup the ACE_Hash_Map_Manager_Ex. - ~ACE_Hash_Map_Manager_Ex (void); + ~ACE_Hash_Map_Manager_Ex (); /** * Associate @a item with @a int_id. If @a item is already in the @@ -390,11 +390,11 @@ public: /// Returns the current number of ACE_Hash_Map_Entry objects in the /// hash table. - size_t current_size (void) const; + size_t current_size () const; /// Return the size of the array that's used to point to the /// linked lists of ACE_Hash_Map_Entry objects in the hash table. - size_t total_size (void) const; + size_t total_size () const; /** * Returns a reference to the underlying <ACE_LOCK>. This makes it @@ -404,24 +404,24 @@ public: * guard the state of an iterator. * @note The right name would be <lock>, but HP/C++ will choke on that! */ - ACE_LOCK &mutex (void); + ACE_LOCK &mutex (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iterator factory functions. /// Return forward iterator. - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; + iterator begin (); + iterator end (); + const_iterator begin () const; + const_iterator end () const; /// Return reverse iterator. - reverse_iterator rbegin (void); - reverse_iterator rend (void); - const_reverse_iterator rbegin (void) const; - const_reverse_iterator rend (void) const; + reverse_iterator rbegin (); + reverse_iterator rend (); + const_reverse_iterator rbegin () const; + const_reverse_iterator rend () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -523,11 +523,11 @@ protected: /// Close down a <Map_Manager_Ex>. Must be called with /// locks held. - int close_i (void); + int close_i (); /// Removes all the entries in <Map_Manager_Ex>. Must be called with /// locks held. - int unbind_all_i (void); + int unbind_all_i (); /// Pointer to a memory allocator used for table_, so it should /// supply size*sizeof (ACE_Hash_Map_Entry<EXT_ID, INT_ID>), @@ -555,7 +555,7 @@ protected: size_t &loc); /// Accessor of the underlying table - ACE_Hash_Map_Entry<EXT_ID, INT_ID> *table (void); + ACE_Hash_Map_Entry<EXT_ID, INT_ID> *table (); private: /** @@ -634,17 +634,17 @@ public: int next (ACE_Hash_Map_Entry<EXT_ID, INT_ID> *&next_entry) const; /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Returns a reference to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* () const; /// Returns a pointer to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> () const; /// Returns reference the Hash_Map_Manager_Ex that is being iterated /// over. - ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (void); + ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (); /// Check if two iterators point to the same position bool operator== (const ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &) const; @@ -656,14 +656,14 @@ public: protected: /// Move forward by one element in the set. Returns 0 when there's /// no more item in the set after the current items, else 1. - int forward_i (void); + int forward_i (); /// Move backward by one element in the set. Returns 0 when there's /// no more item in the set before the current item, else 1. - int reverse_i (void); + int reverse_i (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Map we are iterating over. ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> *map_man_; @@ -710,17 +710,17 @@ public: int next (ACE_Hash_Map_Entry<EXT_ID, INT_ID> *&next_entry) const; /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Returns a reference to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* () const; /// Returns a pointer to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> () const; /// Returns reference the Hash_Map_Manager_Ex that is being iterated /// over. - const ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (void); + const ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (); /// Check if two iterators point to the same position bool operator== (const ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &) const; @@ -732,14 +732,14 @@ public: protected: /// Move forward by one element in the set. Returns 0 when there's /// no more item in the set after the current items, else 1. - int forward_i (void); + int forward_i (); /// Move backward by one element in the set. Returns 0 when there's /// no more item in the set before the current item, else 1. - int reverse_i (void); + int reverse_i (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Map we are iterating over. const ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> *map_man_; @@ -798,21 +798,21 @@ public: // = Iteration methods. /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix advance. - ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (void); + ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (); /// Postfix advance. ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (void); + ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (); /// Postfix reverse. ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator-- (int); @@ -854,21 +854,21 @@ public: // = Iteration methods. /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix advance. - ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (void); + ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (); /// Postfix advance. ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (void); + ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (); /// Postfix reverse. ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator-- (int); @@ -918,26 +918,26 @@ public: // = STL styled iteration, compare, and reference functions. /// Prefix advance. - ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (void); + ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (); /// Postfix advance. ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (void); + ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (); /// Postfix reverse. ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator-- (int); /// Returns a reference to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>& operator* () const; /// Returns a pointer to the interal element @c this is pointing to. - ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> (void) const; + ACE_Hash_Map_Entry<EXT_ID, INT_ID>* operator-> () const; /// Returns reference the Hash_Map_Manager_Ex that is being iterated /// over. - ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (void); + ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& map (); /// Check if two iterators point to the same position bool operator== (const ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &) const; @@ -946,11 +946,11 @@ public: protected: /// Move forward by one element in the set. Returns 0 when there's /// no more item in the set after the current items, else 1. - int forward_i (void); + int forward_i (); /// Move backward by one element in the set. Returns 0 when there's /// no more item in the set before the current item, else 1. - int reverse_i (void); + int reverse_i (); /// Map we are iterating over. ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> *map_man_; @@ -996,21 +996,21 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix reverse. - ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (void); + ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (); /// Postfix reverse. ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix advance. - ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (void); + ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (); /// Postfix advance. ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator-- (int); @@ -1052,21 +1052,21 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix reverse. - ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (void); + ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator++ (); /// Postfix reverse. ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix advance. - ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (void); + ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> &operator-- (); /// Postfix advance. ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> operator-- (int); diff --git a/ACE/ace/Hash_Map_Manager_T.inl b/ACE/ace/Hash_Map_Manager_T.inl index 7af638f58f0..479bbe9c11f 100644 --- a/ACE/ace/Hash_Map_Manager_T.inl +++ b/ACE/ace/Hash_Map_Manager_T.inl @@ -32,7 +32,7 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::ACE_H } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close () { ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1); @@ -40,7 +40,7 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::close } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::unbind_all (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::unbind_all () { ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1); @@ -48,25 +48,25 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::unbin } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::~ACE_Hash_Map_Manager_Ex (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::~ACE_Hash_Map_Manager_Ex () { this->close (); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE size_t -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::current_size (void) const +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::current_size () const { return this->cur_size_; } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE size_t -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::total_size (void) const +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::total_size () const { return this->total_size_; } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_LOCK & -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::mutex (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::mutex () { ACE_TRACE ("ACE_Hash_Map_Manager_Ex::mutex"); return this->lock_; @@ -372,63 +372,63 @@ ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rebin template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::begin (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::begin () { return iterator (*this); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::end (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::end () { return iterator (*this, 1); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::const_iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::begin (void) const +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::begin () const { return const_iterator (*this); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::const_iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::end (void) const +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::end () const { return const_iterator (*this, 1); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rbegin (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rbegin () { return reverse_iterator (*this); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_iterator -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rend (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rend () { return reverse_iterator (*this, 1); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::const_reverse_iterator - ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rbegin (void) const + ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rbegin () const { return const_reverse_iterator (*this); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE typename ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::const_reverse_iterator - ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rend (void) const + ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::rend () const { return const_reverse_iterator (*this, 1); } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> * -ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::table (void) +ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::table () { return this->table_; } @@ -536,7 +536,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done (void) const +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done () const { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done"); @@ -547,7 +547,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> & -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* (void) const +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* () const { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator*"); ACE_Hash_Map_Entry<EXT_ID, INT_ID> *retv = 0; @@ -562,7 +562,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> * -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> (void) const +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> () const { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator->"); ACE_Hash_Map_Entry<EXT_ID, INT_ID> *retv = 0; @@ -579,7 +579,7 @@ ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>: // iterated over. template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& -ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map (void) +ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map () { ACE_TRACE ("ACE_Hash_Map_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map"); return *this->map_man_; @@ -634,7 +634,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done (void) const +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done () const { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::done"); @@ -645,7 +645,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> & -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* (void) const +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* () const { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator*"); ACE_Hash_Map_Entry<EXT_ID, INT_ID> *retv = 0; @@ -660,7 +660,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> * -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> (void) const +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> () const { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator->"); ACE_Hash_Map_Entry<EXT_ID, INT_ID> *retv = 0; @@ -677,7 +677,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ // iterated over. template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE const ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>& -ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map (void) +ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map"); return *this->map_man_; @@ -702,7 +702,7 @@ ACE_Hash_Map_Const_Iterator_Base_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_ } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -751,7 +751,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance"); return this->forward_i (); @@ -759,7 +759,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::adva template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -780,7 +780,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::oper template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); @@ -800,7 +800,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::oper } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -821,7 +821,7 @@ ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance"); return this->forward_i (); @@ -829,7 +829,7 @@ ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -850,7 +850,7 @@ ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); @@ -886,7 +886,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -907,7 +907,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); @@ -927,7 +927,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i (void) +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i () { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::forward_i"); @@ -936,7 +936,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> int -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i (void) +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i () { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::reverse_i"); @@ -946,7 +946,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> & -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* (void) const +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator* () const { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator*"); @@ -955,7 +955,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Entry<EXT_ID, INT_ID> * -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> (void) const +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-> () const { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator->"); @@ -964,7 +964,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map (void) +ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map () { ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::map"); return *this->map_man_; @@ -989,7 +989,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>:: } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -1008,7 +1008,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance"); return this->reverse_i (); @@ -1016,7 +1016,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -1037,7 +1037,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); @@ -1057,7 +1057,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -1076,7 +1076,7 @@ ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, A } template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::advance"); return this->reverse_i (); @@ -1084,7 +1084,7 @@ ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, A template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -1105,7 +1105,7 @@ ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, A template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> & -ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_Hash_Map_Const_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); diff --git a/ACE/ace/High_Res_Timer.h b/ACE/ace/High_Res_Timer.h index 848ec99040c..ff4d544159b 100644 --- a/ACE/ace/High_Res_Timer.h +++ b/ACE/ace/High_Res_Timer.h @@ -120,7 +120,7 @@ public: static void global_scale_factor (global_scale_factor_type gsf); /// Returns the global_scale_factor. - static global_scale_factor_type global_scale_factor (void); + static global_scale_factor_type global_scale_factor (); #ifndef ACE_HR_SCALE_CONVERSION # define ACE_HR_SCALE_CONVERSION (ACE_ONE_SECOND_IN_USECS) @@ -151,13 +151,13 @@ public: const u_int iterations = 10); /// Initialize the timer. - ACE_High_Res_Timer (void); + ACE_High_Res_Timer (); /// Destructor. - ~ACE_High_Res_Timer (void); + ~ACE_High_Res_Timer (); /// Reinitialize the timer. - void reset (void); + void reset (); /// Start timing. void start (const ACE_OS::ACE_HRTimer_Op = ACE_OS::ACE_HRTIMER_GETTIME); @@ -213,7 +213,7 @@ public: ACE_HANDLE handle = ACE_STDOUT) const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -224,7 +224,7 @@ public: * as the gettimeofday function, thereby basing the timer calculations * on the high res timer rather than wall clock time. */ - static ACE_Time_Value gettimeofday_hr (void); + static ACE_Time_Value gettimeofday_hr (); /** * @deprecated THIS FUNCTION IS DEPRECATED. PLEASE USE @@ -252,7 +252,7 @@ public: * factor. If there are any problems getting it, we just return 1 * (the default). */ - static ACE_UINT32 get_cpuinfo (void); + static ACE_UINT32 get_cpuinfo (); #endif /* defined (ACE_LINUX) && !ACE_LACKS_SSCANF */ private: diff --git a/ACE/ace/High_Res_Timer.inl b/ACE/ace/High_Res_Timer.inl index fd0a1e8b088..34dc21d383b 100644 --- a/ACE/ace/High_Res_Timer.inl +++ b/ACE/ace/High_Res_Timer.inl @@ -69,7 +69,7 @@ ACE_High_Res_Timer::gettimeofday (const ACE_OS::ACE_HRTimer_Op op) /// function, which is deprecated. If it gets removed, please move the /// code down here, intact. ACE_INLINE ACE_Time_Value -ACE_High_Res_Timer::gettimeofday_hr (void) +ACE_High_Res_Timer::gettimeofday_hr () { return ACE_High_Res_Timer::gettimeofday (); } @@ -106,7 +106,7 @@ ACE_High_Res_Timer::elapsed_hrtime (const ACE_hrtime_t end, } ACE_INLINE -ACE_High_Res_Timer::~ACE_High_Res_Timer (void) +ACE_High_Res_Timer::~ACE_High_Res_Timer () { } diff --git a/ACE/ace/Intrusive_Auto_Ptr.cpp b/ACE/ace/Intrusive_Auto_Ptr.cpp index 69ecffe2852..c437ce99e42 100644 --- a/ACE/ace/Intrusive_Auto_Ptr.cpp +++ b/ACE/ace/Intrusive_Auto_Ptr.cpp @@ -12,7 +12,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Intrusive_Auto_Ptr) template <class X> -ACE_Intrusive_Auto_Ptr<X>::~ACE_Intrusive_Auto_Ptr (void) +ACE_Intrusive_Auto_Ptr<X>::~ACE_Intrusive_Auto_Ptr () { reset (0); } diff --git a/ACE/ace/Intrusive_Auto_Ptr.h b/ACE/ace/Intrusive_Auto_Ptr.h index 36ff94901b8..c2eae90691b 100644 --- a/ACE/ace/Intrusive_Auto_Ptr.h +++ b/ACE/ace/Intrusive_Auto_Ptr.h @@ -73,7 +73,7 @@ public: /// Destructor. Releases the reference to the underlying representation. /// If the release of that reference causes its reference count to reach 0, /// the representation object will also be destroyed. - virtual ~ACE_Intrusive_Auto_Ptr (void); + virtual ~ACE_Intrusive_Auto_Ptr (); /// Assignment operator that binds the current object and @a r to the same /// ACE_Intrusive_Auto_Ptr_Rep. An ACE_Intrusive_Auto_Ptr_Rep @@ -81,24 +81,24 @@ public: void operator = (const ACE_Intrusive_Auto_Ptr<X> &r); /// Redirection operator - X *operator-> (void) const; + X *operator-> () const; /// Accessor method. X &operator *() const; /// Releases the reference to the underlying representation object. /// @retval The pointer value prior to releasing it. - X *release (void); + X *release (); /// Releases the current pointer value and then sets a new /// pointer value specified by @a p. void reset (X *p = 0); /// Get the pointer value. - X *get (void) const; + X *get () const; /// Get the reference count value. - long count (void) const; + long count () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; diff --git a/ACE/ace/Intrusive_Auto_Ptr.inl b/ACE/ace/Intrusive_Auto_Ptr.inl index a37f2f3b25b..f208d6feb4b 100644 --- a/ACE/ace/Intrusive_Auto_Ptr.inl +++ b/ACE/ace/Intrusive_Auto_Ptr.inl @@ -21,7 +21,7 @@ ACE_Intrusive_Auto_Ptr<X>::ACE_Intrusive_Auto_Ptr (const ACE_Intrusive_Auto_Ptr< } template <class X> ACE_INLINE X * -ACE_Intrusive_Auto_Ptr<X>::operator-> (void) const +ACE_Intrusive_Auto_Ptr<X>::operator-> () const { return this->rep_; } @@ -33,14 +33,14 @@ ACE_Intrusive_Auto_Ptr<X>::operator *() const } template <class X> ACE_INLINE X* -ACE_Intrusive_Auto_Ptr<X>::get (void) const +ACE_Intrusive_Auto_Ptr<X>::get () const { // We return the ACE_Future_rep. return this->rep_; } template<class X> ACE_INLINE X * -ACE_Intrusive_Auto_Ptr<X>::release (void) +ACE_Intrusive_Auto_Ptr<X>::release () { X *p = this->rep_; if (this->rep_ != 0) diff --git a/ACE/ace/Intrusive_List.cpp b/ACE/ace/Intrusive_List.cpp index 0623adbe493..54bafc4c7b7 100644 --- a/ACE/ace/Intrusive_List.cpp +++ b/ACE/ace/Intrusive_List.cpp @@ -14,14 +14,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class T> -ACE_Intrusive_List<T>::ACE_Intrusive_List (void) +ACE_Intrusive_List<T>::ACE_Intrusive_List () : head_ (0) , tail_ (0) { } template<class T> -ACE_Intrusive_List<T>::~ACE_Intrusive_List (void) +ACE_Intrusive_List<T>::~ACE_Intrusive_List () { } @@ -64,7 +64,7 @@ ACE_Intrusive_List<T>::push_front (T *node) } template<class T> T * -ACE_Intrusive_List<T>::pop_front (void) +ACE_Intrusive_List<T>::pop_front () { T *node = this->head_; if (node != 0) @@ -75,7 +75,7 @@ ACE_Intrusive_List<T>::pop_front (void) } template<class T> T * -ACE_Intrusive_List<T>::pop_back (void) +ACE_Intrusive_List<T>::pop_back () { T *node = this->tail_; if (node != 0) diff --git a/ACE/ace/Intrusive_List.h b/ACE/ace/Intrusive_List.h index 2ed02750b35..d5ba0534d41 100644 --- a/ACE/ace/Intrusive_List.h +++ b/ACE/ace/Intrusive_List.h @@ -57,15 +57,15 @@ class ACE_Intrusive_List public: /// Constructor. Use user specified allocation strategy /// if specified. - ACE_Intrusive_List (void); + ACE_Intrusive_List (); /// Destructor. - ~ACE_Intrusive_List (void); + ~ACE_Intrusive_List (); // = Check boundary conditions. /// Returns true if the container is empty, otherwise returns false. - bool is_empty (void) const; + bool is_empty () const; /// Insert an element at the beginning of the list void push_front (T *node); @@ -74,16 +74,16 @@ public: void push_back (T *node); /// Remove the element at the beginning of the list - T *pop_front (void); + T *pop_front (); /// Remove the element at the end of the list - T *pop_back (void); + T *pop_back (); /// Get the element at the head of the queue - T *head (void) const; + T *head () const; /// Get the element at the tail of the queue - T *tail (void) const; + T *tail () const; /// Remove a element from the list /** diff --git a/ACE/ace/Intrusive_List.inl b/ACE/ace/Intrusive_List.inl index 17d7a15653e..ae004a341a0 100644 --- a/ACE/ace/Intrusive_List.inl +++ b/ACE/ace/Intrusive_List.inl @@ -4,19 +4,19 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class T> ACE_INLINE bool -ACE_Intrusive_List<T>::is_empty (void) const +ACE_Intrusive_List<T>::is_empty () const { return this->head_ == 0; } template<class T> ACE_INLINE T * -ACE_Intrusive_List<T>::head (void) const +ACE_Intrusive_List<T>::head () const { return this->head_; } template<class T> ACE_INLINE T * -ACE_Intrusive_List<T>::tail (void) const +ACE_Intrusive_List<T>::tail () const { return this->tail_; } diff --git a/ACE/ace/Intrusive_List_Node.cpp b/ACE/ace/Intrusive_List_Node.cpp index 830ea4b1ce7..74f27993d02 100644 --- a/ACE/ace/Intrusive_List_Node.cpp +++ b/ACE/ace/Intrusive_List_Node.cpp @@ -14,7 +14,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class T> -ACE_Intrusive_List_Node<T>::ACE_Intrusive_List_Node (void) +ACE_Intrusive_List_Node<T>::ACE_Intrusive_List_Node () : prev_ (0) , next_ (0) { diff --git a/ACE/ace/Intrusive_List_Node.h b/ACE/ace/Intrusive_List_Node.h index 732a5179242..366083712e5 100644 --- a/ACE/ace/Intrusive_List_Node.h +++ b/ACE/ace/Intrusive_List_Node.h @@ -44,9 +44,9 @@ public: * */ //@{ - T *prev (void) const; + T *prev () const; void prev (T *); - T *next (void) const; + T *next () const; void next (T *); //@} @@ -56,7 +56,7 @@ protected: * The constructor is protected, because only derived classes should * be instantiated. */ - ACE_Intrusive_List_Node (void); + ACE_Intrusive_List_Node (); private: /// Head and tail of the list diff --git a/ACE/ace/Intrusive_List_Node.inl b/ACE/ace/Intrusive_List_Node.inl index 220453adc46..d26a78a4179 100644 --- a/ACE/ace/Intrusive_List_Node.inl +++ b/ACE/ace/Intrusive_List_Node.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class T> ACE_INLINE T* -ACE_Intrusive_List_Node<T>::prev (void) const +ACE_Intrusive_List_Node<T>::prev () const { return this->prev_; } @@ -14,7 +14,7 @@ ACE_Intrusive_List_Node<T>::prev (T *x) } template<class T> ACE_INLINE T* -ACE_Intrusive_List_Node<T>::next (void) const +ACE_Intrusive_List_Node<T>::next () const { return this->next_; } 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_; }; diff --git a/ACE/ace/Lock.inl b/ACE/ace/Lock.inl index 43b4bac0898..f2ad9996716 100644 --- a/ACE/ace/Lock.inl +++ b/ACE/ace/Lock.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Lock::ACE_Lock (void) +ACE_Lock::ACE_Lock () { } diff --git a/ACE/ace/Lock_Adapter_T.cpp b/ACE/ace/Lock_Adapter_T.cpp index 0068e8ae0d1..9bf13d3fc9a 100644 --- a/ACE/ace/Lock_Adapter_T.cpp +++ b/ACE/ace/Lock_Adapter_T.cpp @@ -15,7 +15,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class ACE_LOCKING_MECHANISM> -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::~ACE_Lock_Adapter (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::~ACE_Lock_Adapter () { if (this->delete_lock_) delete this->lock_; @@ -23,14 +23,14 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::~ACE_Lock_Adapter (void) // Explicitly destroy the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::remove (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::remove () { return this->lock_->remove (); } // Block the thread until the lock is acquired. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire () { return this->lock_->acquire (); } @@ -38,7 +38,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire (void) // Conditionally acquire the lock (i.e., won't block). template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire () { return this->lock_->tryacquire (); } @@ -46,7 +46,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire (void) // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::release (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::release () { return this->lock_->release (); } @@ -56,7 +56,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::release (void) // <acquire>. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_read (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_read () { return this->lock_->acquire_read (); } @@ -66,7 +66,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_read (void) // <acquire>. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_write (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_write () { return this->lock_->acquire_write (); } @@ -75,7 +75,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_write (void) // doesn't support read locks then this just calls <acquire>. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_read (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_read () { return this->lock_->tryacquire_read (); } @@ -84,7 +84,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_read (void) // doesn't support write locks then this just calls <acquire>. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write () { return this->lock_->tryacquire_write (); } @@ -94,7 +94,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write (void) // calls <acquire>. Returns 0 on success, -1 on failure. template <class ACE_LOCKING_MECHANISM> int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade () { return this->lock_->tryacquire_write_upgrade (); } diff --git a/ACE/ace/Lock_Adapter_T.h b/ACE/ace/Lock_Adapter_T.h index 2e1f0a53290..ece637ae264 100644 --- a/ACE/ace/Lock_Adapter_T.h +++ b/ACE/ace/Lock_Adapter_T.h @@ -46,53 +46,53 @@ public: /// Constructor. Since no lock is provided by the user, one will be /// created internally. - ACE_Lock_Adapter (void); + ACE_Lock_Adapter (); /// Destructor. If @c lock_ was not passed in by the user, it will be /// deleted. - virtual ~ACE_Lock_Adapter (void); + virtual ~ACE_Lock_Adapter (); // = Lock accessors. /// Block the thread until the lock is acquired. - virtual int acquire (void); + virtual int acquire (); /// Conditionally acquire the lock (i.e., won't block). - virtual int tryacquire (void); + virtual int tryacquire (); /// Release the lock. - virtual int release (void); + virtual int release (); /** * Block until the thread acquires a read lock. If the locking * mechanism doesn't support read locks then this just calls * acquire(). */ - virtual int acquire_read (void); + virtual int acquire_read (); /** * Block until the thread acquires a write lock. If the locking * mechanism doesn't support read locks then this just calls * acquire(). */ - virtual int acquire_write (void); + virtual int acquire_write (); /// Conditionally acquire a read lock. If the locking mechanism /// doesn't support read locks then this just calls acquire(). - virtual int tryacquire_read (void); + virtual int tryacquire_read (); /// Conditionally acquire a write lock. If the locking mechanism /// doesn't support read locks then this just calls acquire(). - virtual int tryacquire_write (void); + virtual int tryacquire_write (); /** * 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); + virtual int tryacquire_write_upgrade (); /// Explicitly destroy the lock. - virtual int remove (void); + virtual int remove (); private: /// The concrete locking mechanism that all the methods delegate to. diff --git a/ACE/ace/Lock_Adapter_T.inl b/ACE/ace/Lock_Adapter_T.inl index 5de19ea5b2f..efffe4980af 100644 --- a/ACE/ace/Lock_Adapter_T.inl +++ b/ACE/ace/Lock_Adapter_T.inl @@ -14,7 +14,7 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter ( template <class ACE_LOCKING_MECHANISM> ACE_INLINE -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter (void) +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter () : lock_ (0), delete_lock_ (true) { diff --git a/ACE/ace/Log_Msg.h b/ACE/ace/Log_Msg.h index 6a3e481197e..474962401a3 100644 --- a/ACE/ace/Log_Msg.h +++ b/ACE/ace/Log_Msg.h @@ -245,16 +245,16 @@ public: }; /// Returns a pointer to the Singleton. - static ACE_Log_Msg *instance (void); + static ACE_Log_Msg *instance (); /// Returns last error. - static int last_error_adapter (void); + static int last_error_adapter (); /// Returns non-null if an ACE_Log_Msg exists for the calling thread. - static int exists (void); + static int exists (); /// Returns the current program name used for logging. - static const ACE_TCHAR * program_name (void); + static const ACE_TCHAR * program_name (); /// Clears the flag from the default priority mask used to /// initialize ACE_Log_Msg instances. @@ -265,10 +265,10 @@ public: static void enable_debug_messages (ACE_Log_Priority priority = LM_DEBUG); /// Initialize logger. - ACE_Log_Msg (void); + ACE_Log_Msg (); /// cleanup logger. - ~ACE_Log_Msg (void); + ~ACE_Log_Msg (); /// Initialize the ACE logging facility. /** @@ -308,7 +308,7 @@ public: /** * Return the bits in the logger's options flags. */ - u_long flags (void); + u_long flags (); /** @name Allow apps to acquire and release internal synchronization * lock @@ -320,10 +320,10 @@ public: //@{ /// Acquire the internal lock. - int acquire (void); + int acquire (); /// Release the internal lock. - int release (void); + int release (); //@} /// Call after doing a @c fork() to resynchronize the process id and @@ -339,7 +339,7 @@ public: /// Get the result of the operation status (by convention, -1 means /// error). - int op_status (void) const; + int op_status () const; /// Set the value of the errnum (by convention this corresponds to /// errno). @@ -347,25 +347,25 @@ public: /// Get the value of the errnum (by convention this corresponds to /// errno). - int errnum (void) const; + int errnum () const; /// Set the line number where an error occurred. void linenum (int); /// Get the line number where an error occurred. - int linenum (void) const; + int linenum () const; /// Set the file name where an error occurred. void file (const char *); /// Get the file name where an error occurred. - const char *file (void); + const char *file (); /// Set the message that describes what type of error occurred. void msg (const ACE_TCHAR *); /// Get the message that describes what type of error occurred. - const ACE_TCHAR *msg (void); + const ACE_TCHAR *msg (); /// Set the field that indicates whether interrupted calls should be /// restarted. @@ -373,7 +373,7 @@ public: /// Get the field that indicates whether interrupted calls should be /// restarted. - bool restart (void) const; + bool restart () const; // = Notice that the following two function is equivalent to // "void msg_ostream (HANDLE)" and "HANDLE msg_ostream (void)" @@ -390,7 +390,7 @@ public: void msg_ostream (ACE_OSTREAM_TYPE *, bool delete_ostream); /// Get the ostream that is used to print error messages. - ACE_OSTREAM_TYPE *msg_ostream (void) const; + ACE_OSTREAM_TYPE *msg_ostream () const; /** * Set a new callback object and return the existing callback to @@ -399,7 +399,7 @@ public: * them in each thread. */ ACE_Log_Msg_Callback *msg_callback (ACE_Log_Msg_Callback *c); - ACE_Log_Msg_Callback *msg_callback (void) const; + ACE_Log_Msg_Callback *msg_callback () const; /** * Set a new backend object and return the existing backend to @@ -411,28 +411,28 @@ public: * on a backend object. */ static ACE_Log_Msg_Backend *msg_backend (ACE_Log_Msg_Backend *b); - static ACE_Log_Msg_Backend *msg_backend (void); + static ACE_Log_Msg_Backend *msg_backend (); /// Nesting depth increment. - int inc (void); + int inc (); /// Nesting depth decrement. - int dec (void); + int dec (); /// Get trace depth. - int trace_depth (void) const; + int trace_depth () const; /// Set trace depth. void trace_depth (int); /// Get trace active status. - bool trace_active (void) const; + bool trace_active () const; /// Set trace active status. void trace_active (bool value); /// Get the TSS thread descriptor. - ACE_Thread_Descriptor *thr_desc (void) const; + ACE_Thread_Descriptor *thr_desc () const; /** * Set the TSS thread descriptor. This method will call @@ -442,13 +442,13 @@ public: void thr_desc (ACE_Thread_Descriptor *td); /// Stop tracing status on a per-thread basis... - void stop_tracing (void); + void stop_tracing (); /// Start tracing status on a per-thread basis... - void start_tracing (void); + void start_tracing (); /// Query tracing status on a per-thread basis... - bool tracing_enabled (void) const; + bool tracing_enabled () const; typedef enum { @@ -486,10 +486,10 @@ public: /// Optimize reading of the pid (avoids a system call if the value is /// cached...). - pid_t getpid (void) const; + pid_t getpid () const; /// Get the name of the local host. - const ACE_TCHAR *local_host (void) const; + const ACE_TCHAR *local_host () const; /// Set the name of the local host. void local_host (const ACE_TCHAR *); @@ -626,7 +626,7 @@ public: ACE_OS_Log_Msg_Attributes &attributes); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -749,13 +749,13 @@ private: #endif /* ACE_MT_SAFE */ /// For cleanup, at program termination. - static void close (void); + static void close (); /// Decouple the OS layer from the ACE_Log_Msg layer. static void sync_hook (const ACE_TCHAR *prg_name); /// Return the TSS singleton thread descriptor - static ACE_OS_Thread_Descriptor *thr_desc_hook (void); + static ACE_OS_Thread_Descriptor *thr_desc_hook (); //friend void ACE_OS::cleanup_tss (const u_int); diff --git a/ACE/ace/Log_Msg.inl b/ACE/ace/Log_Msg.inl index 1062c15c6b1..bca6dc2271f 100644 --- a/ACE/ace/Log_Msg.inl +++ b/ACE/ace/Log_Msg.inl @@ -31,7 +31,7 @@ ACE_Log_Msg::op_status (int status) ACE_INLINE int -ACE_Log_Msg::op_status (void) const +ACE_Log_Msg::op_status () const { return this->status_; } @@ -45,14 +45,14 @@ ACE_Log_Msg::restart (bool r) ACE_INLINE bool -ACE_Log_Msg::restart (void) const +ACE_Log_Msg::restart () const { return this->restart_; } ACE_INLINE int -ACE_Log_Msg::errnum (void) const +ACE_Log_Msg::errnum () const { return this->errnum_; } @@ -66,7 +66,7 @@ ACE_Log_Msg::errnum (int e) ACE_INLINE int -ACE_Log_Msg::linenum (void) const +ACE_Log_Msg::linenum () const { return this->linenum_; } @@ -80,21 +80,21 @@ ACE_Log_Msg::linenum (int l) ACE_INLINE int -ACE_Log_Msg::inc (void) +ACE_Log_Msg::inc () { return this->trace_depth_++; } ACE_INLINE int -ACE_Log_Msg::dec (void) +ACE_Log_Msg::dec () { return this->trace_depth_ == 0 ? 0 : --this->trace_depth_; } ACE_INLINE int -ACE_Log_Msg::trace_depth (void) const +ACE_Log_Msg::trace_depth () const { return this->trace_depth_; } @@ -108,7 +108,7 @@ ACE_Log_Msg::trace_depth (int depth) ACE_INLINE bool -ACE_Log_Msg::trace_active (void) const +ACE_Log_Msg::trace_active () const { return this->trace_active_; } @@ -122,7 +122,7 @@ ACE_Log_Msg::trace_active (bool value) ACE_INLINE ACE_Thread_Descriptor * -ACE_Log_Msg::thr_desc (void) const +ACE_Log_Msg::thr_desc () const { return this->thr_desc_; } @@ -130,7 +130,7 @@ ACE_Log_Msg::thr_desc (void) const /// Enable the tracing facility on a per-thread basis. ACE_INLINE void -ACE_Log_Msg::start_tracing (void) +ACE_Log_Msg::start_tracing () { this->tracing_enabled_ = true; } @@ -138,21 +138,21 @@ ACE_Log_Msg::start_tracing (void) /// Disable the tracing facility on a per-thread basis. ACE_INLINE void -ACE_Log_Msg::stop_tracing (void) +ACE_Log_Msg::stop_tracing () { this->tracing_enabled_ = false; } ACE_INLINE bool -ACE_Log_Msg::tracing_enabled (void) const +ACE_Log_Msg::tracing_enabled () const { return this->tracing_enabled_; } ACE_INLINE const char * -ACE_Log_Msg::file (void) +ACE_Log_Msg::file () { return this->file_; } @@ -166,7 +166,7 @@ ACE_Log_Msg::file (const char *s) ACE_INLINE const ACE_TCHAR * -ACE_Log_Msg::msg (void) +ACE_Log_Msg::msg () { return this->msg_ + ACE_Log_Msg::msg_off_; } @@ -181,7 +181,7 @@ ACE_Log_Msg::msg (const ACE_TCHAR *m) ACE_INLINE ACE_Log_Msg_Callback * -ACE_Log_Msg::msg_callback (void) const +ACE_Log_Msg::msg_callback () const { return this->msg_callback_; } @@ -197,7 +197,7 @@ ACE_Log_Msg::msg_callback (ACE_Log_Msg_Callback *c) ACE_INLINE ACE_OSTREAM_TYPE * -ACE_Log_Msg::msg_ostream (void) const +ACE_Log_Msg::msg_ostream () const { return this->ostream_; } @@ -211,14 +211,14 @@ ACE_Log_Msg::msg_ostream (ACE_OSTREAM_TYPE *m) ACE_INLINE const ACE_TCHAR * -ACE_Log_Msg::local_host (void) const +ACE_Log_Msg::local_host () const { return ACE_Log_Msg::local_host_; } ACE_INLINE pid_t -ACE_Log_Msg::getpid (void) const +ACE_Log_Msg::getpid () const { return ACE_OS::getpid (); } diff --git a/ACE/ace/Malloc_Base.h b/ACE/ace/Malloc_Base.h index 267021ce799..76e63076bd6 100644 --- a/ACE/ace/Malloc_Base.h +++ b/ACE/ace/Malloc_Base.h @@ -45,20 +45,20 @@ public: // = Memory Management /// Get pointer to a default ACE_Allocator. - static ACE_Allocator *instance (void); + static ACE_Allocator *instance (); /// Set pointer to a process-wide ACE_Allocator and return existing /// pointer. static ACE_Allocator *instance (ACE_Allocator *); /// Delete the dynamically allocated Singleton - static void close_singleton (void); + static void close_singleton (); /// "No-op" constructor (needed to make certain compilers happy). - ACE_Allocator (void); + ACE_Allocator (); /// Virtual destructor - virtual ~ACE_Allocator (void); + virtual ~ACE_Allocator (); /// Allocate @a nbytes, but don't give them any initial value. virtual void *malloc (size_type nbytes) = 0; @@ -76,7 +76,7 @@ public: virtual void free (void *ptr) = 0; /// Remove any resources associated with this memory manager. - virtual int remove (void) = 0; + virtual int remove () = 0; // = Map manager like functions @@ -149,7 +149,7 @@ public: #endif /* ACE_HAS_MALLOC_STATS */ /// Dump the state of the object. - virtual void dump (void) const = 0; + virtual void dump () const = 0; private: // DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!! See the // <ACE_Allocator::instance> implementation for explanation. diff --git a/ACE/ace/Managed_Object.cpp b/ACE/ace/Managed_Object.cpp index 3935cf96f0d..b6f512202fe 100644 --- a/ACE/ace/Managed_Object.cpp +++ b/ACE/ace/Managed_Object.cpp @@ -18,7 +18,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class TYPE> -ACE_Cleanup_Adapter<TYPE>::~ACE_Cleanup_Adapter (void) +ACE_Cleanup_Adapter<TYPE>::~ACE_Cleanup_Adapter () { } diff --git a/ACE/ace/Managed_Object.h b/ACE/ace/Managed_Object.h index 207c0abfc35..eed45cbbc23 100644 --- a/ACE/ace/Managed_Object.h +++ b/ACE/ace/Managed_Object.h @@ -42,13 +42,13 @@ class ACE_Cleanup_Adapter : public ACE_Cleanup { public: /// Default constructor. - ACE_Cleanup_Adapter (void); + ACE_Cleanup_Adapter (); /// Virtual destructor, needed by some compilers for vtable placement. - virtual ~ACE_Cleanup_Adapter (void); + virtual ~ACE_Cleanup_Adapter (); /// Accessor for contained object. - TYPE &object (void); + TYPE &object (); private: ACE_UNIMPLEMENTED_FUNC (ACE_Cleanup_Adapter (const ACE_Cleanup_Adapter<TYPE> &)) diff --git a/ACE/ace/Managed_Object.inl b/ACE/ace/Managed_Object.inl index 4747e8faa2b..c3b3acae0a1 100644 --- a/ACE/ace/Managed_Object.inl +++ b/ACE/ace/Managed_Object.inl @@ -3,7 +3,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class TYPE> ACE_INLINE -ACE_Cleanup_Adapter<TYPE>::ACE_Cleanup_Adapter (void) +ACE_Cleanup_Adapter<TYPE>::ACE_Cleanup_Adapter () // Note: don't explicitly initialize "object_", because TYPE may not // have a default constructor. Let the compiler figure it out . . . { @@ -12,7 +12,7 @@ ACE_Cleanup_Adapter<TYPE>::ACE_Cleanup_Adapter (void) template <class TYPE> ACE_INLINE TYPE & -ACE_Cleanup_Adapter<TYPE>::object (void) +ACE_Cleanup_Adapter<TYPE>::object () { return this->object_; } diff --git a/ACE/ace/Manual_Event.cpp b/ACE/ace/Manual_Event.cpp index d0504f84e62..91235a610e0 100644 --- a/ACE/ace/Manual_Event.cpp +++ b/ACE/ace/Manual_Event.cpp @@ -44,7 +44,7 @@ ACE_Manual_Event_T<TIME_POLICY>::ACE_Manual_Event_T ( template <class TIME_POLICY> void -ACE_Manual_Event_T<TIME_POLICY>::dump (void) const +ACE_Manual_Event_T<TIME_POLICY>::dump () const { #if defined (ACE_HAS_DUMP) ACE_Event_T<TIME_POLICY>::dump (); diff --git a/ACE/ace/Manual_Event.h b/ACE/ace/Manual_Event.h index 5287eec3e27..a2981f41ffd 100644 --- a/ACE/ace/Manual_Event.h +++ b/ACE/ace/Manual_Event.h @@ -53,10 +53,10 @@ public: #endif /* ACE_HAS_WCHAR */ /// Default dtor. - ~ACE_Manual_Event_T (void); + ~ACE_Manual_Event_T (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks ACE_ALLOC_HOOK_DECLARE; @@ -85,7 +85,7 @@ public: #endif /* ACE_HAS_WCHAR */ /// Default dtor. - virtual ~ACE_Manual_Event (void) {} + virtual ~ACE_Manual_Event () {} }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/Manual_Event.inl b/ACE/ace/Manual_Event.inl index d72fdfc85e6..7db9b7b0ebd 100644 --- a/ACE/ace/Manual_Event.inl +++ b/ACE/ace/Manual_Event.inl @@ -3,7 +3,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class TIME_POLICY> ACE_INLINE -ACE_Manual_Event_T<TIME_POLICY>::~ACE_Manual_Event_T (void) +ACE_Manual_Event_T<TIME_POLICY>::~ACE_Manual_Event_T () { } diff --git a/ACE/ace/Map_Manager.cpp b/ACE/ace/Map_Manager.cpp index ecb34ab503b..fb7d6046cf6 100644 --- a/ACE/ace/Map_Manager.cpp +++ b/ACE/ace/Map_Manager.cpp @@ -57,7 +57,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::open (size_t size, } template <class EXT_ID, class INT_ID, class ACE_LOCK> int -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close_i (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close_i () { // Free entries. this->free_search_structure (); @@ -385,7 +385,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::find_and_return_index (const EXT_ID & } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind_all (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind_all () { // Go through the entire occupied list. for (ACE_UINT32 i = this->occupied_list_.next (); @@ -551,7 +551,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::resize_i (ACE_UINT32 new_size) } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_UINT32 -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::new_size (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::new_size () { // Calculate the new size. ACE_UINT32 current_size = this->total_size_; @@ -568,7 +568,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::new_size (void) } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_search_structure (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_search_structure () { // Free up the structure. if (this->search_structure_ != 0) @@ -590,7 +590,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_search_structure (void) } template <class EXT_ID, class INT_ID> void -ACE_Map_Entry<EXT_ID, INT_ID>::dump (void) const +ACE_Map_Entry<EXT_ID, INT_ID>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -606,7 +606,7 @@ ACE_Map_Entry<EXT_ID, INT_ID>::dump (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -619,7 +619,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i (void) const +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -629,7 +629,7 @@ ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i (void) const +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -639,7 +639,7 @@ ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::dump_i (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const +ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -647,7 +647,7 @@ ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const +ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); @@ -655,7 +655,7 @@ ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> void -ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump (void) const +ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) this->dump_i (); diff --git a/ACE/ace/Map_Manager.h b/ACE/ace/Map_Manager.h index e4c541957de..4ca68a32721 100644 --- a/ACE/ace/Map_Manager.h +++ b/ACE/ace/Map_Manager.h @@ -38,11 +38,11 @@ class ACE_Map_Entry { public: /// Initialize member variables. - ACE_Map_Entry (void); + ACE_Map_Entry (); /// We need this destructor to keep some compilers from complaining. /// It's just a no-op, however. - ~ACE_Map_Entry (void); + ~ACE_Map_Entry (); /// Key used to look up an entry. EXT_ID ext_id_; @@ -51,7 +51,7 @@ public: INT_ID int_id_; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -60,13 +60,13 @@ public: // are not portable. /// Get next entry. - ACE_UINT32 next (void) const; + ACE_UINT32 next () const; /// Set next entry. void next (ACE_UINT32 n); /// Get prev entry. - ACE_UINT32 prev (void) const; + ACE_UINT32 prev () const; /// Set prev entry. void prev (ACE_UINT32 p); @@ -157,11 +157,11 @@ public: /// Close down a ACE_Map_Manager and release dynamically allocated /// resources. - int close (void); + int close (); /// Close down a ACE_Map_Manager and release dynamically allocated /// resources. - ~ACE_Map_Manager (void); + ~ACE_Map_Manager (); /** * Associate @a ext_id with @a int_id. If @a ext_id is already in the @@ -248,13 +248,13 @@ public: /** * Unbind all entires. */ - void unbind_all (void); + void unbind_all (); /// Return the current size of the map. - size_t current_size (void) const; + size_t current_size () const; /// Return the total size of the map. - size_t total_size (void) const; + size_t total_size () const; /** * Returns a reference to the underlying ACE_LOCK. This makes it @@ -264,20 +264,20 @@ public: * guard the state of an iterator. * @note The right name would be lock, but HP/C++ will choke on that! */ - ACE_LOCK &mutex (void); + ACE_LOCK &mutex (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iterator factory functions. /// Return forward iterator. - ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> begin (void); - ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> end (void); + ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> begin (); + ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> end (); /// Return reverse iterator. - ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> rbegin (void); - ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> rend (void); + ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> rbegin (); + ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> rend (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -353,7 +353,7 @@ protected: int resize_i (ACE_UINT32 size); /// Close down a <Map_Manager>. Must be called with locks held. - int close_i (void); + int close_i (); /// Returns 1 if <id1> == <id2>, else 0. This is defined as a /// separate method to facilitate template specialization. @@ -361,17 +361,17 @@ protected: /// This function returns the new size of the Map Manager. This /// function is called when we run out of room and need to resize. - ACE_UINT32 new_size (void); + ACE_UINT32 new_size (); /// Explicitly call the destructors and free up the /// <search_structure_>. - void free_search_structure (void); + void free_search_structure (); /// Id of the free list sentinel. - ACE_UINT32 free_list_id (void) const; + ACE_UINT32 free_list_id () const; /// Id of the occupied list sentinel. - ACE_UINT32 occupied_list_id (void) const; + ACE_UINT32 occupied_list_id () const; /// Finds the next free slot. int next_free (ACE_UINT32 &slot); @@ -460,14 +460,14 @@ public: int next (ACE_Map_Entry<EXT_ID, INT_ID> *&next_entry) const; /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Returns a reference to the interal element @c this is pointing to. - ACE_Map_Entry<EXT_ID, INT_ID>& operator* (void) const; + ACE_Map_Entry<EXT_ID, INT_ID>& operator* () const; /// Returns reference the Map_Manager that is being iterated /// over. - ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>& map (void); + ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>& map (); /// Check if two iterators point to the same position bool operator== (const ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &) const; @@ -479,14 +479,14 @@ public: protected: /// Move forward by one element in the set. Returns 0 when there's /// no more item in the set after the current items, else 1. - int forward_i (void); + int forward_i (); /// Move backware by one element in the set. Returns 0 when there's /// no more item in the set before the current item, else 1. - int reverse_i (void); + int reverse_i (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Map we are iterating over. ACE_Map_Manager <EXT_ID, INT_ID, ACE_LOCK> *map_man_; @@ -518,14 +518,14 @@ public: int next (ACE_Map_Entry<EXT_ID, INT_ID> *&next_entry) const; /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Returns a reference to the interal element @c this is pointing to. - ACE_Map_Entry<EXT_ID, INT_ID>& operator* (void) const; + ACE_Map_Entry<EXT_ID, INT_ID>& operator* () const; /// Returns reference the Map_Manager that is being iterated /// over. - const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>& map (void) const; + const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>& map () const; /// Check if two iterators point to the same position bool operator== (const ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK> &) const; @@ -537,14 +537,14 @@ public: protected: /// Move forward by one element in the set. Returns 0 when there's /// no more item in the set after the current items, else 1. - int forward_i (void); + int forward_i (); /// Move backware by one element in the set. Returns 0 when there's /// no more item in the set before the current item, else 1. - int reverse_i (void); + int reverse_i (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; /// Map we are iterating over. const ACE_Map_Manager <EXT_ID, INT_ID, ACE_LOCK> *map_man_; @@ -576,21 +576,21 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix advance. - ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (void); + ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (); /// Postfix advance. ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (void); + ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (); /// Postfix reverse. ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator-- (int); @@ -622,21 +622,21 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix advance. - ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (void); + ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (); /// Postfix advance. ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (void); + ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (); /// Postfix reverse. ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator-- (int); @@ -668,21 +668,21 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. /// Prefix reverse. - ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (void); + ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator++ (); /// Postfix reverse. ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator++ (int); /// Prefix advance. - ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (void); + ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> &operator-- (); /// Postfix advance. ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> operator-- (int); diff --git a/ACE/ace/Map_Manager.inl b/ACE/ace/Map_Manager.inl index 3c132b4f9bf..5ef512b49ed 100644 --- a/ACE/ace/Map_Manager.inl +++ b/ACE/ace/Map_Manager.inl @@ -5,7 +5,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class EXT_ID, class INT_ID> ACE_INLINE -ACE_Map_Entry<EXT_ID, INT_ID>::ACE_Map_Entry (void) +ACE_Map_Entry<EXT_ID, INT_ID>::ACE_Map_Entry () : next_ (0), prev_ (0) #if defined (ACE_HAS_LAZY_MAP_MANAGER) @@ -15,13 +15,13 @@ ACE_Map_Entry<EXT_ID, INT_ID>::ACE_Map_Entry (void) } template <class EXT_ID, class INT_ID> ACE_INLINE -ACE_Map_Entry<EXT_ID, INT_ID>::~ACE_Map_Entry (void) +ACE_Map_Entry<EXT_ID, INT_ID>::~ACE_Map_Entry () { // No-op just to keep some compilers happy... } template <class EXT_ID, class INT_ID> ACE_INLINE ACE_UINT32 -ACE_Map_Entry<EXT_ID, INT_ID>::next (void) const +ACE_Map_Entry<EXT_ID, INT_ID>::next () const { return this->next_; } @@ -33,7 +33,7 @@ ACE_Map_Entry<EXT_ID, INT_ID>::next (ACE_UINT32 n) } template <class EXT_ID, class INT_ID> ACE_INLINE ACE_UINT32 -ACE_Map_Entry<EXT_ID, INT_ID>::prev (void) const +ACE_Map_Entry<EXT_ID, INT_ID>::prev () const { return this->prev_; } @@ -68,7 +68,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Manager (ACE_Allocator *alloc } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close () { ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1); @@ -76,7 +76,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::close (void) } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::~ACE_Map_Manager (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::~ACE_Map_Manager () { this->close (); } @@ -186,21 +186,21 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::unbind (const EXT_ID &ext_id) } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE size_t -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::current_size (void) const +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::current_size () const { ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, static_cast<size_t> (-1)); return this->cur_size_; } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE size_t -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::total_size (void) const +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::total_size () const { ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, static_cast<size_t> (-1)); return this->total_size_; } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_LOCK & -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::mutex (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::mutex () { return this->lock_; } @@ -233,7 +233,7 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::equal (const EXT_ID &id1, } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_UINT32 -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_list_id (void) const +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_list_id () const { // If you change ~0, please change // ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key() @@ -242,35 +242,35 @@ ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::free_list_id (void) const } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_UINT32 -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::occupied_list_id (void) const +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::occupied_list_id () const { return (ACE_UINT32) ~1; } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::begin (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::begin () { return ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::end (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::end () { return ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this, 1); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rbegin (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rbegin () { return ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> -ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rend (void) +ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK>::rend () { return ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> (*this, 1); } @@ -295,13 +295,13 @@ ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::next (ACE_Map_Entry<EXT_ID, INT } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done (void) const +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done () const { return this->next_ == this->map_man_->occupied_list_id (); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i (void) +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i () { #if defined (ACE_HAS_LAZY_MAP_MANAGER) @@ -332,7 +332,7 @@ ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i (void) } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i (void) +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i () { #if defined (ACE_HAS_LAZY_MAP_MANAGER) @@ -364,7 +364,7 @@ ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i (void) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map (void) +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map () { return *this->map_man_; } @@ -402,13 +402,13 @@ ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::next (ACE_Map_Entry<EXT_I } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done (void) const +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::done () const { return this->next_ == this->map_man_->occupied_list_id (); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i (void) +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i () { #if defined (ACE_HAS_LAZY_MAP_MANAGER) @@ -439,7 +439,7 @@ ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::forward_i (void) } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i (void) +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i () { #if defined (ACE_HAS_LAZY_MAP_MANAGER) @@ -471,7 +471,7 @@ ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::reverse_i (void) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE const ACE_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map (void) const +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::map () const { return *this->map_man_; } @@ -528,14 +528,14 @@ ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Iterator (ACE_Map_Manager<EX } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance (void) +ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance () { return this->forward_i (); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (void) +ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ () { this->forward_i (); return *this; @@ -552,7 +552,7 @@ ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (void) +ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- () { this->reverse_i (); return *this; @@ -606,14 +606,14 @@ ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Const_Iterator (const } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance (void) +ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance () { return this->forward_i (); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (void) +ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ () { this->forward_i (); return *this; @@ -630,7 +630,7 @@ ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (void) +ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- () { this->reverse_i (); return *this; @@ -684,14 +684,14 @@ ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::ACE_Map_Reverse_Iterator (AC } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE int -ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance (void) +ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::advance () { return this->reverse_i (); } template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (void) +ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ () { this->reverse_i (); return *this; @@ -708,7 +708,7 @@ ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> & -ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (void) +ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- () { this->forward_i (); return *this; @@ -725,7 +725,7 @@ ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int) template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Entry<EXT_ID, INT_ID>& -ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* (void) const +ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* () const { ACE_Map_Entry<EXT_ID, INT_ID> *retv = 0; @@ -738,7 +738,7 @@ ACE_Map_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* (void) const template <class EXT_ID, class INT_ID, class ACE_LOCK> ACE_INLINE ACE_Map_Entry<EXT_ID, INT_ID>& -ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* (void) const +ACE_Map_Const_Iterator_Base<EXT_ID, INT_ID, ACE_LOCK>::operator* () const { ACE_Map_Entry<EXT_ID, INT_ID> *retv = 0; diff --git a/ACE/ace/Map_T.cpp b/ACE/ace/Map_T.cpp index f67f07ef8f8..6ebb44e61dd 100644 --- a/ACE/ace/Map_T.cpp +++ b/ACE/ace/Map_T.cpp @@ -14,28 +14,28 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class KEY, class VALUE> -ACE_Map<KEY, VALUE>::~ACE_Map (void) +ACE_Map<KEY, VALUE>::~ACE_Map () { } template <class T> -ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void) +ACE_Iterator_Impl<T>::~ACE_Iterator_Impl () { } template <class T> -ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void) +ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl () { } template <class T, class IMPLEMENTATION, class ENTRY> -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void) +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter () { } template <class T, class IMPLEMENTATION, class ENTRY> ACE_Iterator_Impl<T> * -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone () const { ACE_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -62,24 +62,24 @@ ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const } template <class T, class IMPLEMENTATION, class ENTRY> void -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus () { ++this->implementation_; } template <class T, class IMPLEMENTATION, class ENTRY> void -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus () { --this->implementation_; } template <class T, class IMPLEMENTATION, class ENTRY> -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void) +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter () { } template <class T, class IMPLEMENTATION, class ENTRY> ACE_Reverse_Iterator_Impl<T> * -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone () const { ACE_Reverse_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -107,20 +107,20 @@ ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () } template <class T, class IMPLEMENTATION, class ENTRY> void -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus () { ++this->implementation_; } template <class T, class IMPLEMENTATION, class ENTRY> void -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus () { --this->implementation_; } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl () { } @@ -133,7 +133,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ope } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close () { return this->implementation_.close (); } @@ -249,19 +249,19 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unb } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size () const { return this->implementation_.current_size (); } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size () const { return this->implementation_.total_size (); } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> void -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump () const { #if defined (ACE_HAS_DUMP) this->implementation_.dump (); @@ -269,7 +269,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dum } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -279,7 +279,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::beg } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -289,7 +289,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -299,7 +299,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbe } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -309,12 +309,12 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ren } template <class T, class VALUE> -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void) +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter () { } template <class T, class VALUE> ACE_Iterator_Impl<T> * -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone () const { ACE_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -343,24 +343,24 @@ ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const } template <class T, class VALUE> void -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void) +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus () { ++this->implementation_; } template <class T, class VALUE> void -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void) +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus () { --this->implementation_; } template <class T, class VALUE> -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void) +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter () { } template <class T, class VALUE> ACE_Reverse_Iterator_Impl<T> * -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone () const { ACE_Reverse_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -389,19 +389,19 @@ ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const } template <class T, class VALUE> void -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void) +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus () { ++this->implementation_; } template <class T, class VALUE> void -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void) +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus () { --this->implementation_; } template <class KEY, class VALUE, class KEY_ADAPTER> -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter () { } @@ -414,7 +414,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length, } template <class KEY, class VALUE, class KEY_ADAPTER> int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close () { return this->implementation_.close (); } @@ -691,19 +691,19 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, } template <class KEY, class VALUE, class KEY_ADAPTER> size_t -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size () const { return this->implementation_.current_size (); } template <class KEY, class VALUE, class KEY_ADAPTER> size_t -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size () const { return this->implementation_.total_size (); } template <class KEY, class VALUE, class KEY_ADAPTER> void -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump () const { #if defined (ACE_HAS_DUMP) this->implementation_.dump (); @@ -711,7 +711,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -721,7 +721,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void) } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -731,7 +731,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void) } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -741,7 +741,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void) } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -751,12 +751,12 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void) } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void) +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter () { } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Iterator_Impl<T> * -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone () const { ACE_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -785,24 +785,24 @@ ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>: } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus () { ++this->implementation_; } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus () { --this->implementation_; } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void) +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter () { } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Reverse_Iterator_Impl<T> * -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone () const { ACE_Reverse_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -831,19 +831,19 @@ ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPAR } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus () { ++this->implementation_; } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus () { --this->implementation_; } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter () { } @@ -856,7 +856,7 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close () { return this->implementation_.close (); } @@ -984,19 +984,19 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size () const { return this->implementation_.current_size (); } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size () const { return this->implementation_.total_size (); } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> void -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump () const { #if defined (ACE_HAS_DUMP) this->implementation_.dump (); @@ -1004,7 +1004,7 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1014,7 +1014,7 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1024,7 +1024,7 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1034,7 +1034,7 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1044,12 +1044,12 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class T, class KEY, class VALUE> -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void) +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter () { } template <class T, class KEY, class VALUE> ACE_Iterator_Impl<T> * -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone () const { ACE_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -1078,24 +1078,24 @@ ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const } template <class T, class KEY, class VALUE> void -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus () { ++this->implementation_; } template <class T, class KEY, class VALUE> void -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus () { --this->implementation_; } template <class T, class KEY, class VALUE> -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void) +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter () { } template <class T, class KEY, class VALUE> ACE_Reverse_Iterator_Impl<T> * -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone () const { ACE_Reverse_Iterator_Impl<T> *temp = 0; ACE_NEW_RETURN (temp, @@ -1124,19 +1124,19 @@ ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const } template <class T, class KEY, class VALUE> void -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus () { ++this->implementation_; } template <class T, class KEY, class VALUE> void -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus () { --this->implementation_; } template <class KEY, class VALUE, class KEY_GENERATOR> -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter () { } @@ -1149,7 +1149,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length, } template <class KEY, class VALUE, class KEY_GENERATOR> int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close () { return this->implementation_.close (); } @@ -1277,19 +1277,19 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key, } template <class KEY, class VALUE, class KEY_GENERATOR> size_t -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size () const { return this->implementation_.current_size (); } template <class KEY, class VALUE, class KEY_GENERATOR> size_t -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size () const { return this->implementation_.total_size (); } template <class KEY, class VALUE, class KEY_GENERATOR> void -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump () const { #if defined (ACE_HAS_DUMP) this->implementation_.dump (); @@ -1297,7 +1297,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1307,7 +1307,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void) } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl () { ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1317,7 +1317,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void) } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, @@ -1327,7 +1327,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void) } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl () { ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; ACE_NEW_RETURN (temp, diff --git a/ACE/ace/Map_T.h b/ACE/ace/Map_T.h index 3da8e4809d8..bb8938acaa3 100644 --- a/ACE/ace/Map_T.h +++ b/ACE/ace/Map_T.h @@ -56,13 +56,13 @@ class ACE_Incremental_Key_Generator public: /// Constructor. - ACE_Incremental_Key_Generator (void); + ACE_Incremental_Key_Generator (); /// Functor method: generates a new key. int operator () (T &t); /// Returns the current value. - const T& current_value (void) const; + const T& current_value () const; protected: @@ -83,22 +83,22 @@ class ACE_Iterator_Impl public: /// Destructor. - virtual ~ACE_Iterator_Impl (void); + virtual ~ACE_Iterator_Impl (); /// Clone. - virtual ACE_Iterator_Impl<T> *clone (void) const = 0; + virtual ACE_Iterator_Impl<T> *clone () const = 0; /// Comparison. virtual int compare (const ACE_Iterator_Impl<T> &rhs) const = 0; /// Dereference. - virtual T dereference (void) const = 0; + virtual T dereference () const = 0; /// Advance. - virtual void plus_plus (void) = 0; + virtual void plus_plus () = 0; /// Reverse. - virtual void minus_minus (void) = 0; + virtual void minus_minus () = 0; }; /** @@ -114,22 +114,22 @@ class ACE_Reverse_Iterator_Impl public: /// Destructor. - virtual ~ACE_Reverse_Iterator_Impl (void); + virtual ~ACE_Reverse_Iterator_Impl (); /// Clone. - virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const = 0; + virtual ACE_Reverse_Iterator_Impl<T> *clone () const = 0; /// Comparison. virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const = 0; /// Dereference. - virtual T dereference (void) const = 0; + virtual T dereference () const = 0; /// Advance. - virtual void plus_plus (void) = 0; + virtual void plus_plus () = 0; /// Reverse. - virtual void minus_minus (void) = 0; + virtual void minus_minus () = 0; }; /** @@ -155,7 +155,7 @@ public: ACE_Iterator (const ACE_Iterator<T> &rhs); /// Destructor. - ~ACE_Iterator (void); + ~ACE_Iterator (); /// Assignment operator. ACE_Iterator<T> &operator= (const ACE_Iterator<T> &rhs); @@ -168,19 +168,19 @@ public: T operator *() const; /// Prefix advance. - ACE_Iterator<T> &operator++ (void); + ACE_Iterator<T> &operator++ (); /// Postfix advance. ACE_Iterator<T> operator++ (int); /// Prefix reverse. - ACE_Iterator<T> &operator-- (void); + ACE_Iterator<T> &operator-- (); /// Postfix reverse. ACE_Iterator<T> operator-- (int); /// Accessor to implementation object. - ACE_Iterator_Impl<T> &impl (void); + ACE_Iterator_Impl<T> &impl (); protected: @@ -211,7 +211,7 @@ public: ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rhs); /// Destructor. - ~ACE_Reverse_Iterator (void); + ~ACE_Reverse_Iterator (); /// Assignment operator. ACE_Reverse_Iterator<T> &operator= (const ACE_Reverse_Iterator<T> &rhs); @@ -230,19 +230,19 @@ public: T operator *() const; /// Prefix advance. - ACE_Reverse_Iterator<T> &operator++ (void); + ACE_Reverse_Iterator<T> &operator++ (); /// Postfix advance. ACE_Reverse_Iterator<T> operator++ (int); /// Prefix reverse. - ACE_Reverse_Iterator<T> &operator-- (void); + ACE_Reverse_Iterator<T> &operator-- (); /// Postfix reverse. ACE_Reverse_Iterator<T> operator-- (int); /// Accessor to implementation object. - ACE_Reverse_Iterator_Impl<T> &impl (void); + ACE_Reverse_Iterator_Impl<T> &impl (); protected: @@ -279,14 +279,14 @@ public: reverse_iterator_implementation; /// Close down and release dynamically allocated resources. - virtual ~ACE_Map (void); + virtual ~ACE_Map (); /// Initialize a map with size @a length. virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc = 0) = 0; /// Close down a <Map> and release dynamically allocated resources. - virtual int close (void) = 0; + virtual int close () = 0; /** * Add @a key / @a value pair to the map. If @a key is already in the @@ -404,36 +404,36 @@ public: VALUE &value) = 0; /// Return the current size of the map. - virtual size_t current_size (void) const = 0; + virtual size_t current_size () const = 0; /// Return the total size of the map. - virtual size_t total_size (void) const = 0; + virtual size_t total_size () const = 0; /// Dump the state of an object. - virtual void dump (void) const = 0; + virtual void dump () const = 0; // = STL styled iterator factory functions. /// Return forward iterator. - iterator begin (void); - iterator end (void); + iterator begin (); + iterator end (); /// Return reverse iterator. - reverse_iterator rbegin (void); - reverse_iterator rend (void); + reverse_iterator rbegin (); + reverse_iterator rend (); protected: // = Protected no-op constructor. - ACE_Map (void); + ACE_Map (); /// Return forward iterator. - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void) = 0; - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void) = 0; + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl () = 0; + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl () = 0; /// Return reverse iterator. - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void) = 0; - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void) = 0; + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl () = 0; + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl () = 0; private: @@ -462,25 +462,25 @@ public: ACE_Map_Impl_Iterator_Adapter (const IMPLEMENTATION &impl); /// Destructor. - virtual ~ACE_Map_Impl_Iterator_Adapter (void); + virtual ~ACE_Map_Impl_Iterator_Adapter (); /// Clone. - virtual ACE_Iterator_Impl<T> *clone (void) const; + virtual ACE_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - IMPLEMENTATION &impl (void); + IMPLEMENTATION &impl (); protected: @@ -508,25 +508,25 @@ public: ACE_Map_Impl_Reverse_Iterator_Adapter (const IMPLEMENTATION &impl); /// Destructor. - virtual ~ACE_Map_Impl_Reverse_Iterator_Adapter (void); + virtual ~ACE_Map_Impl_Reverse_Iterator_Adapter (); /// Clone. - virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const; + virtual ACE_Reverse_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - IMPLEMENTATION &impl (void); + IMPLEMENTATION &impl (); protected: @@ -563,14 +563,14 @@ public: ACE_Allocator *alloc = 0); /// Close down and release dynamically allocated resources. - virtual ~ACE_Map_Impl (void); + virtual ~ACE_Map_Impl (); /// Initialize a <Map> with size @a length. virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc = 0); /// Close down a <Map> and release dynamically allocated resources. - virtual int close (void); + virtual int close (); /** * Add @a key / @a value pair to the map. If @a key is already in the @@ -688,16 +688,16 @@ public: VALUE &value); /// Return the current size of the map. - virtual size_t current_size (void) const; + virtual size_t current_size () const; /// Return the total size of the map. - virtual size_t total_size (void) const; + virtual size_t total_size () const; /// Dump the state of an object. - virtual void dump (void) const; + virtual void dump () const; /// Accessor to implementation object. - IMPLEMENTATION &impl (void); + IMPLEMENTATION &impl (); protected: @@ -707,12 +707,12 @@ protected: // = STL styled iterator factory functions. /// Return forward iterator. - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void); - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (); /// Return reverse iterator. - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void); - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (); private: @@ -741,25 +741,25 @@ public: ACE_Active_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Active_Map_Manager_Iterator_Adapter (void); + virtual ~ACE_Active_Map_Manager_Iterator_Adapter (); /// Clone. - virtual ACE_Iterator_Impl<T> *clone (void) const; + virtual ACE_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (void); + ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (); protected: @@ -787,25 +787,25 @@ public: ACE_Active_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void); + virtual ~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (); /// Clone. - virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const; + virtual ACE_Reverse_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (void); + ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (); protected: @@ -843,14 +843,14 @@ public: ACE_Allocator *alloc = 0); /// Close down and release dynamically allocated resources. - virtual ~ACE_Active_Map_Manager_Adapter (void); + virtual ~ACE_Active_Map_Manager_Adapter (); /// Initialize a Map with size @a length. virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc = 0); /// Close down a Map and release dynamically allocated resources. - virtual int close (void); + virtual int close (); /** * Add @a key / @a value pair to the map. If @a key is already in the @@ -967,19 +967,19 @@ public: VALUE &value); /// Return the current size of the map. - virtual size_t current_size (void) const; + virtual size_t current_size () const; /// Return the total size of the map. - virtual size_t total_size (void) const; + virtual size_t total_size () const; /// Dump the state of an object. - virtual void dump (void) const; + virtual void dump () const; /// Accessor to implementation object. - ACE_Active_Map_Manager<std::pair<KEY, VALUE> > &impl (void); + ACE_Active_Map_Manager<std::pair<KEY, VALUE> > &impl (); /// Accessor to key adapter. - KEY_ADAPTER &key_adapter (void); + KEY_ADAPTER &key_adapter (); protected: @@ -1000,12 +1000,12 @@ protected: // = STL styled iterator factory functions. /// Return forward iterator. - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void); - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (); /// Return reverse iterator. - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void); - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (); private: @@ -1034,25 +1034,25 @@ public: ACE_Hash_Map_Manager_Ex_Iterator_Adapter (const ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void); + virtual ~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (); /// Clone. - virtual ACE_Iterator_Impl<T> *clone (void) const; + virtual ACE_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void); + ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (); protected: @@ -1080,25 +1080,25 @@ public: ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (const ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void); + virtual ~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (); /// Clone. - virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const; + virtual ACE_Reverse_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void); + ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (); protected: @@ -1134,14 +1134,14 @@ public: ACE_Allocator *alloc = 0); /// Close down and release dynamically allocated resources. - virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void); + virtual ~ACE_Hash_Map_Manager_Ex_Adapter (); /// Initialize a Map with size @a length. virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc = 0); /// Close down a Map and release dynamically allocated resources. - virtual int close (void); + virtual int close (); /** * Add @a key / @a value pair to the map. If @a key is already in the @@ -1259,19 +1259,19 @@ public: VALUE &value); /// Return the current size of the map. - virtual size_t current_size (void) const; + virtual size_t current_size () const; /// Return the total size of the map. - virtual size_t total_size (void) const; + virtual size_t total_size () const; /// Dump the state of an object. - virtual void dump (void) const; + virtual void dump () const; /// Accessor to implementation object. - ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void); + ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (); /// Accessor to key generator. - KEY_GENERATOR &key_generator (void); + KEY_GENERATOR &key_generator (); protected: @@ -1284,12 +1284,12 @@ protected: // = STL styled iterator factory functions. /// Return forward iterator. - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void); - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (); /// Return reverse iterator. - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void); - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (); private: @@ -1318,25 +1318,25 @@ public: ACE_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Map_Manager_Iterator_Adapter (void); + virtual ~ACE_Map_Manager_Iterator_Adapter (); /// Clone. - virtual ACE_Iterator_Impl<T> *clone (void) const; + virtual ACE_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (void); + ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (); protected: @@ -1364,25 +1364,25 @@ public: ACE_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl); /// Destructor. - virtual ~ACE_Map_Manager_Reverse_Iterator_Adapter (void); + virtual ~ACE_Map_Manager_Reverse_Iterator_Adapter (); /// Clone. - virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const; + virtual ACE_Reverse_Iterator_Impl<T> *clone () const; /// Comparison. virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const; /// Dereference. - virtual T dereference (void) const; + virtual T dereference () const; /// Advance. - virtual void plus_plus (void); + virtual void plus_plus (); /// Reverse. - virtual void minus_minus (void); + virtual void minus_minus (); /// Accessor to implementation object. - ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (void); + ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (); protected: @@ -1418,14 +1418,14 @@ public: ACE_Allocator *alloc = 0); /// Close down and release dynamically allocated resources. - virtual ~ACE_Map_Manager_Adapter (void); + virtual ~ACE_Map_Manager_Adapter (); /// Initialize a <Map> with size @a length. virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE, ACE_Allocator *alloc = 0); /// Close down a <Map> and release dynamically allocated resources. - virtual int close (void); + virtual int close (); /** * Add @a key / @a value pair to the map. If @a key is already in the @@ -1543,19 +1543,19 @@ public: VALUE &value); /// Return the current size of the map. - virtual size_t current_size (void) const; + virtual size_t current_size () const; /// Return the total size of the map. - virtual size_t total_size (void) const; + virtual size_t total_size () const; /// Dump the state of an object. - virtual void dump (void) const; + virtual void dump () const; /// Accessor to implementation object. - ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &impl (void); + ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &impl (); /// Accessor to key generator. - KEY_GENERATOR &key_generator (void); + KEY_GENERATOR &key_generator (); protected: @@ -1568,12 +1568,12 @@ protected: // = STL styled iterator factory functions. /// Return forward iterator. - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void); - virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (); + virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (); /// Return reverse iterator. - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void); - virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (); + virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (); private: diff --git a/ACE/ace/Map_T.inl b/ACE/ace/Map_T.inl index 1e4ae9b8173..076819c4d2c 100644 --- a/ACE/ace/Map_T.inl +++ b/ACE/ace/Map_T.inl @@ -8,7 +8,7 @@ ACE_Noop_Key_Generator<T>::operator() (T &) } template <class T> ACE_INLINE -ACE_Incremental_Key_Generator<T>::ACE_Incremental_Key_Generator (void) +ACE_Incremental_Key_Generator<T>::ACE_Incremental_Key_Generator () : t_ (0) { } @@ -21,7 +21,7 @@ ACE_Incremental_Key_Generator<T>::operator() (T &t) } template <class T> ACE_INLINE const T & -ACE_Incremental_Key_Generator<T>::current_value (void) const +ACE_Incremental_Key_Generator<T>::current_value () const { return this->t_; } @@ -39,7 +39,7 @@ ACE_Iterator<T>::ACE_Iterator (const ACE_Iterator<T> &rhs) } template <class T> ACE_INLINE -ACE_Iterator<T>::~ACE_Iterator (void) +ACE_Iterator<T>::~ACE_Iterator () { delete this->implementation_; } @@ -65,13 +65,13 @@ ACE_Iterator<T>::operator!= (const ACE_Iterator<T> &rhs) const } template <class T> ACE_INLINE T -ACE_Iterator<T>::operator* (void) const +ACE_Iterator<T>::operator* () const { return this->implementation_->dereference (); } template <class T> ACE_INLINE ACE_Iterator<T> & -ACE_Iterator<T>::operator++ (void) +ACE_Iterator<T>::operator++ () { this->implementation_->plus_plus (); return *this; @@ -86,7 +86,7 @@ ACE_Iterator<T>::operator++ (int) } template <class T> ACE_INLINE ACE_Iterator<T> & -ACE_Iterator<T>::operator-- (void) +ACE_Iterator<T>::operator-- () { this->implementation_->minus_minus (); return *this; @@ -101,7 +101,7 @@ ACE_Iterator<T>::operator-- (int) } template <class T> ACE_INLINE ACE_Iterator_Impl<T> & -ACE_Iterator<T>::impl (void) +ACE_Iterator<T>::impl () { return *this->implementation_; } @@ -119,7 +119,7 @@ ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rh } template <class T> ACE_INLINE -ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator (void) +ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator () { delete this->implementation_; } @@ -145,13 +145,13 @@ ACE_Reverse_Iterator<T>::operator!= (const ACE_Reverse_Iterator<T> &rhs) const } template <class T> ACE_INLINE T -ACE_Reverse_Iterator<T>::operator* (void) const +ACE_Reverse_Iterator<T>::operator* () const { return this->implementation_->dereference (); } template <class T> ACE_INLINE ACE_Reverse_Iterator<T> & -ACE_Reverse_Iterator<T>::operator++ (void) +ACE_Reverse_Iterator<T>::operator++ () { this->implementation_->plus_plus (); return *this; @@ -166,7 +166,7 @@ ACE_Reverse_Iterator<T>::operator++ (int) } template <class T> ACE_INLINE ACE_Reverse_Iterator<T> & -ACE_Reverse_Iterator<T>::operator-- (void) +ACE_Reverse_Iterator<T>::operator-- () { this->implementation_->minus_minus (); return *this; @@ -181,36 +181,36 @@ ACE_Reverse_Iterator<T>::operator-- (int) } template <class T> ACE_INLINE ACE_Reverse_Iterator_Impl<T> & -ACE_Reverse_Iterator<T>::impl (void) +ACE_Reverse_Iterator<T>::impl () { return *this->implementation_; } template <class KEY, class VALUE> ACE_INLINE -ACE_Map<KEY, VALUE>::ACE_Map (void) +ACE_Map<KEY, VALUE>::ACE_Map () { } template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> > -ACE_Map<KEY, VALUE>::begin (void) +ACE_Map<KEY, VALUE>::begin () { return iterator (this->begin_impl ()); } template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> > -ACE_Map<KEY, VALUE>::end (void) +ACE_Map<KEY, VALUE>::end () { return iterator (this->end_impl ()); } template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> > -ACE_Map<KEY, VALUE>::rbegin (void) +ACE_Map<KEY, VALUE>::rbegin () { return reverse_iterator (this->rbegin_impl ()); } template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> > -ACE_Map<KEY, VALUE>::rend (void) +ACE_Map<KEY, VALUE>::rend () { return reverse_iterator (this->rend_impl ()); } @@ -222,7 +222,7 @@ ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Iterator_A } template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION & -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void) +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl () { return this->implementation_; } @@ -234,7 +234,7 @@ ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Re } template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION & -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void) +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl () { return this->implementation_; } @@ -254,7 +254,7 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE } template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE IMPLEMENTATION & -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl (void) +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl () { return this->implementation_; } @@ -266,7 +266,7 @@ ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Iterat } template <class T, class VALUE> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> & -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl (void) +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl () { return this->implementation_; } @@ -278,7 +278,7 @@ ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manage } template <class T, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> & -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl (void) +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl () { return this->implementation_; } @@ -298,13 +298,13 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_ } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Active_Map_Manager<std::pair<KEY, VALUE> > & -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl () { return this->implementation_; } template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE KEY_ADAPTER & -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::key_adapter (void) +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::key_adapter () { return this->key_adapter_; } @@ -316,7 +316,7 @@ ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>: } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void) +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl () { return this->implementation_; } @@ -328,7 +328,7 @@ ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPAR } template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void) +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl () { return this->implementation_; } @@ -348,13 +348,13 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl () { return this->implementation_; } template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR & -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::key_generator (void) +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::key_generator () { return this->key_generator_; } @@ -366,7 +366,7 @@ ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Iterator_Adapte } template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> & -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl (void) +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl () { return this->implementation_; } @@ -378,7 +378,7 @@ ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Reverse } template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> & -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl (void) +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl () { return this->implementation_; } @@ -398,13 +398,13 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (siz } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> & -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl () { return this->implementation_; } template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR & -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::key_generator (void) +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::key_generator () { return this->key_generator_; } diff --git a/ACE/ace/Message_Block.h b/ACE/ace/Message_Block.h index 1ad30dd0338..954071060f4 100644 --- a/ACE/ace/Message_Block.h +++ b/ACE/ace/Message_Block.h @@ -241,22 +241,22 @@ public: * @note Note that release() is designed to release the continuation * chain; the destructor is not. See release() for details. */ - virtual ~ACE_Message_Block (void); + virtual ~ACE_Message_Block (); // = Message Type accessors and mutators. /// Get type of the message. - ACE_Message_Type msg_type (void) const; + ACE_Message_Type msg_type () const; /// Set type of the message. void msg_type (ACE_Message_Type type); /// Find out what type of message this is. - int is_data_msg (void) const; + int is_data_msg () const; /// Find out what class of message this is (there are two classes, /// @c normal messages and @c high-priority messages). - ACE_Message_Type msg_class (void) const; + ACE_Message_Type msg_class () const; // = Message flag accessors and mutators. /// Bitwise-or the @a more_flags into the existing message flags and @@ -268,7 +268,7 @@ public: Message_Flags clr_flags (Message_Flags less_flags); /// Get the current message flags. - Message_Flags flags (void) const; + Message_Flags flags () const; // = Data Block flag accessors and mutators. /// Bitwise-or the @a more_flags into the existing message flags and @@ -285,22 +285,22 @@ public: Message_Flags clr_self_flags (ACE_Message_Block::Message_Flags less_flags); /// Get the current message flags. - Message_Flags self_flags (void) const; + Message_Flags self_flags () const; /// Get priority of the message. - unsigned long msg_priority (void) const; + unsigned long msg_priority () const; /// Set priority of the message. void msg_priority (unsigned long priority); /// Get execution time associated with the message. - const ACE_Time_Value &msg_execution_time (void) const; + const ACE_Time_Value &msg_execution_time () const; /// Set execution time associated with the message. void msg_execution_time (const ACE_Time_Value &et); /// Get absolute time of deadline associated with the message. - const ACE_Time_Value &msg_deadline_time (void) const; + const ACE_Time_Value &msg_deadline_time () const; /// Set absolute time of deadline associated with the message. void msg_deadline_time (const ACE_Time_Value &dt); @@ -312,7 +312,7 @@ public: virtual ACE_Message_Block *clone (Message_Flags mask = 0) const; /// Return a "shallow" copy that increments our reference count by 1. - virtual ACE_Message_Block *duplicate (void) const; + virtual ACE_Message_Block *duplicate () const; /** * Return a "shallow" copy that increments our reference count by 1. @@ -349,7 +349,7 @@ public: * @retval 0, always, and the object this method was invoked on is no * longer valid. */ - virtual ACE_Message_Block *release (void); + virtual ACE_Message_Block *release (); /** * This behaves like the non-static method release(), except that it @@ -395,11 +395,11 @@ public: /// then readjusts <rd_ptr> to point to <base> and <wr_ptr> to point /// to <base> + the length of the moved data. Returns -1 and does /// nothing if the <rd_ptr> is > <wr_ptr>, else 0 on success. - int crunch (void); + int crunch (); /// Resets the Message Block data to contain nothing, i.e., sets the /// read and write pointers to align with the base. - void reset (void); + void reset (); /// Access all the allocators in the message block. /// @todo Not sure whether we would need finer control while @@ -433,7 +433,7 @@ public: ACE_Allocator *message_block_allocator = 0); /// Get message data. - char *base (void) const; + char *base () const; /// Set message data (doesn't reallocate). void base (char *data, @@ -441,17 +441,17 @@ public: Message_Flags = DONT_DELETE); /// Return a pointer to 1 past the end of the allocated data in a message. - char *end (void) const; + char *end () const; /** * Return a pointer to 1 past the end of the allotted data in a message. * Allotted data may be less than allocated data if a value smaller than * capacity() to is passed to size(). */ - char *mark (void) const; + char *mark () const; /// Get the read pointer. - char *rd_ptr (void) const; + char *rd_ptr () const; /// Set the read pointer to @a ptr. void rd_ptr (char *ptr); @@ -460,7 +460,7 @@ public: void rd_ptr (size_t n); /// Get the write pointer. - char *wr_ptr (void) const; + char *wr_ptr () const; /// Set the write pointer to @a ptr. void wr_ptr (char *ptr); @@ -478,18 +478,18 @@ public: */ //@{ /// Get the length of the message - size_t length (void) const; + size_t length () const; /// Set the length of the message void length (size_t n); /// Get the length of the Message_Blocks, including chained /// Message_Blocks. - size_t total_length (void) const; + size_t total_length () const; /// Get the total number of bytes in all Message_Blocks, including /// chained Message_Blocks. - size_t total_size (void) const; + size_t total_size () const; /// Get the total number of bytes and total length in all /// Message_Blocks, including chained Message_Blocks. @@ -498,7 +498,7 @@ public: /// Get the number of bytes in the top-level Message_Block (i.e., /// does not consider the bytes in chained Message_Blocks). - size_t size (void) const; + size_t size () const; /** * Set the number of bytes in the top-level Message_Block, @@ -510,14 +510,14 @@ public: /// Get the number of allocated bytes in all Message_Block, including /// chained Message_Blocks. - size_t total_capacity (void) const; + size_t total_capacity () const; /// Get the number of allocated bytes in the top-level Message_Block. - size_t capacity (void) const; + size_t capacity () const; /// Get the number of bytes available after the <wr_ptr_> in the /// top-level Message_Block. - size_t space (void) const; + size_t space () const; //@} // = ACE_Data_Block methods. @@ -527,7 +527,7 @@ public: * still references the block; this call does not change the reference * count. */ - ACE_Data_Block *data_block (void) const; + ACE_Data_Block *data_block () const; /** * Set a new data block pointer. The original ACE_Data_Block is released @@ -544,37 +544,37 @@ public: // = The continuation field chains together composite messages. /// Get the continuation field. - ACE_Message_Block *cont (void) const; + ACE_Message_Block *cont () const; /// Set the continuation field. void cont (ACE_Message_Block *); // = Pointer to the Message_Block directly ahead in the ACE_Message_Queue. /// Get link to next message. - ACE_Message_Block *next (void) const; + ACE_Message_Block *next () const; /// Set link to next message. void next (ACE_Message_Block *); // = Pointer to the Message_Block directly behind in the ACE_Message_Queue. /// Get link to prev message. - ACE_Message_Block *prev (void) const; + ACE_Message_Block *prev () const; /// Set link to prev message. void prev (ACE_Message_Block *); // = The locking strategy prevents race conditions. /// Get the locking strategy. - ACE_Lock *locking_strategy (void); + ACE_Lock *locking_strategy (); /// Set a new locking strategy and return the hold one. ACE_Lock *locking_strategy (ACE_Lock *); /// Get the current reference count. - int reference_count (void) const; + int reference_count () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -675,7 +675,7 @@ class ACE_Export ACE_Data_Block { public: /// Default "do-nothing" constructor. - ACE_Data_Block (void); + ACE_Data_Block (); /// Initialize. ACE_Data_Block (size_t size, @@ -687,16 +687,16 @@ public: ACE_Allocator *data_block_allocator); /// Delete all the resources held in the message. - virtual ~ACE_Data_Block (void); + virtual ~ACE_Data_Block (); /// Get type of the message. - ACE_Message_Block::ACE_Message_Type msg_type (void) const; + ACE_Message_Block::ACE_Message_Type msg_type () const; /// Set type of the message. void msg_type (ACE_Message_Block::ACE_Message_Type type); /// Get message data pointer - char *base (void) const; + char *base () const; /// Set message data pointer (doesn't reallocate). void base (char *data, @@ -704,27 +704,27 @@ public: ACE_Message_Block::Message_Flags mflags = ACE_Message_Block::DONT_DELETE); /// Return a pointer to 1 past the end of the allocated data in a message. - char *end (void) const; + char *end () const; /** * Return a pointer to 1 past the end of the allotted data in a message. * The allotted data may be less than allocated data if <size()> is passed * an argument less than <capacity()>. */ - char *mark (void) const; + char *mark () const; // = Message size is the total amount of space allocated. /// Get the total amount of allotted space in the message. The amount of /// allotted space may be less than allocated space. - size_t size (void) const; + size_t size () const; /// Set the total amount of space in the message. Returns 0 if /// successful, else -1. int size (size_t length); /// Get the total amount of allocated space. - size_t capacity (void) const; + size_t capacity () const; /** * Return an exact "deep copy" of the message, i.e., create fresh @@ -747,7 +747,7 @@ public: size_t max_size = 0) const; /// Return a "shallow" copy that increments our reference count by 1. - ACE_Data_Block *duplicate (void); + ACE_Data_Block *duplicate (); /** * Decrease the shared reference count by 1. If the reference count @@ -767,33 +767,33 @@ public: ACE_Message_Block::Message_Flags clr_flags (ACE_Message_Block::Message_Flags less_flags); /// Get the current message flags. - ACE_Message_Block::Message_Flags flags (void) const; + ACE_Message_Block::Message_Flags flags () const; /// Obtain the allocator strategy. - ACE_Allocator *allocator_strategy (void) const; + ACE_Allocator *allocator_strategy () const; // = The locking strategy prevents race conditions. /// Get the locking strategy. - ACE_Lock *locking_strategy (void); + ACE_Lock *locking_strategy (); /// Set a new locking strategy and return the hold one. ACE_Lock *locking_strategy (ACE_Lock *); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Get the current reference count. - int reference_count (void) const; + int reference_count () const; /// Get the allocator used to create this object - ACE_Allocator *data_block_allocator (void) const; + ACE_Allocator *data_block_allocator () const; protected: /// Internal release implementation - virtual ACE_Data_Block *release_i (void); + virtual ACE_Data_Block *release_i (); /// Internal get the current reference count. - int reference_count_i (void) const; + int reference_count_i () const; /** * Decrease the reference count, but don't delete the object. diff --git a/ACE/ace/Message_Block.inl b/ACE/ace/Message_Block.inl index 1bc636fbd7a..f6d69e9cf01 100644 --- a/ACE/ace/Message_Block.inl +++ b/ACE/ace/Message_Block.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Data_Block * -ACE_Message_Block::data_block (void) const +ACE_Message_Block::data_block () const { ACE_TRACE ("ACE_Message_Block::data_block"); return this->data_block_; @@ -27,40 +27,40 @@ ACE_Message_Block::clr_self_flags (ACE_Message_Block::Message_Flags less_flags) } ACE_INLINE ACE_Message_Block::Message_Flags -ACE_Message_Block::self_flags (void) const +ACE_Message_Block::self_flags () const { ACE_TRACE ("ACE_Message_Block::self_flags"); return this->flags_; } ACE_INLINE int -ACE_Data_Block::reference_count_i (void) const +ACE_Data_Block::reference_count_i () const { return reference_count_; } ACE_INLINE int -ACE_Message_Block::reference_count (void) const +ACE_Message_Block::reference_count () const { return data_block () ? data_block ()->reference_count () : 0; } ACE_INLINE char * -ACE_Data_Block::base (void) const +ACE_Data_Block::base () const { ACE_TRACE ("ACE_Data_Block::base"); return this->base_; } ACE_INLINE size_t -ACE_Data_Block::size (void) const +ACE_Data_Block::size () const { ACE_TRACE ("ACE_Data_Block::size"); return this->cur_size_; } ACE_INLINE size_t -ACE_Data_Block::capacity (void) const +ACE_Data_Block::capacity () const { ACE_TRACE ("ACE_Data_Block::capacity"); return this->max_size_; @@ -85,14 +85,14 @@ ACE_Data_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags) } ACE_INLINE ACE_Message_Block::Message_Flags -ACE_Data_Block::flags (void) const +ACE_Data_Block::flags () const { ACE_TRACE ("ACE_Data_Block::flags"); return this->flags_; } ACE_INLINE ACE_Allocator* -ACE_Data_Block::data_block_allocator (void) const +ACE_Data_Block::data_block_allocator () const { ACE_TRACE ("ACE_Data_Block::data_block_allocator"); return this->data_block_allocator_; @@ -113,7 +113,7 @@ ACE_Message_Block::clr_flags (ACE_Message_Block::Message_Flags less_flags) } ACE_INLINE ACE_Message_Block::Message_Flags -ACE_Message_Block::flags (void) const +ACE_Message_Block::flags () const { ACE_TRACE ("ACE_Message_Block::flags"); return this->data_block ()->flags (); @@ -122,7 +122,7 @@ ACE_Message_Block::flags (void) const // Return the length of the "active" portion of the message. ACE_INLINE size_t -ACE_Message_Block::length (void) const +ACE_Message_Block::length () const { ACE_TRACE ("ACE_Message_Block::length"); return this->wr_ptr_ - this->rd_ptr_; @@ -141,21 +141,21 @@ ACE_Message_Block::length (size_t len) // Return the length of the potential size of the message. ACE_INLINE size_t -ACE_Message_Block::size (void) const +ACE_Message_Block::size () const { ACE_TRACE ("ACE_Message_Block::size"); return this->data_block ()->size (); } ACE_INLINE size_t -ACE_Message_Block::capacity (void) const +ACE_Message_Block::capacity () const { ACE_TRACE ("ACE_Message_Block::capacity"); return this->data_block ()->capacity (); } ACE_INLINE ACE_Message_Block::ACE_Message_Type -ACE_Data_Block::msg_type (void) const +ACE_Data_Block::msg_type () const { ACE_TRACE ("ACE_Data_Block::msg_type"); return this->type_; @@ -169,7 +169,7 @@ ACE_Data_Block::msg_type (ACE_Message_Block::ACE_Message_Type t) } ACE_INLINE ACE_Message_Block::ACE_Message_Type -ACE_Message_Block::msg_type (void) const +ACE_Message_Block::msg_type () const { ACE_TRACE ("ACE_Message_Block::msg_type"); return this->data_block ()->msg_type (); @@ -183,7 +183,7 @@ ACE_Message_Block::msg_type (ACE_Message_Block::ACE_Message_Type t) } ACE_INLINE ACE_Message_Block::ACE_Message_Type -ACE_Message_Block::msg_class (void) const +ACE_Message_Block::msg_class () const { ACE_TRACE ("ACE_Message_Block::msg_class"); @@ -196,7 +196,7 @@ ACE_Message_Block::msg_class (void) const } ACE_INLINE int -ACE_Message_Block::is_data_msg (void) const +ACE_Message_Block::is_data_msg () const { ACE_TRACE ("ACE_Message_Block::is_data_msg"); ACE_Message_Type mt = this->msg_type (); @@ -207,7 +207,7 @@ ACE_Message_Block::is_data_msg (void) const } ACE_INLINE unsigned long -ACE_Message_Block::msg_priority (void) const +ACE_Message_Block::msg_priority () const { ACE_TRACE ("ACE_Message_Block::msg_priority"); return this->priority_; @@ -221,7 +221,7 @@ ACE_Message_Block::msg_priority (unsigned long pri) } ACE_INLINE const ACE_Time_Value & -ACE_Message_Block::msg_execution_time (void) const +ACE_Message_Block::msg_execution_time () const { ACE_TRACE ("ACE_Message_Block::msg_execution_time (void)"); #if defined (ACE_HAS_TIMED_MESSAGE_BLOCKS) @@ -243,7 +243,7 @@ ACE_Message_Block::msg_execution_time (const ACE_Time_Value &et) } ACE_INLINE const ACE_Time_Value & -ACE_Message_Block::msg_deadline_time (void) const +ACE_Message_Block::msg_deadline_time () const { ACE_TRACE ("ACE_Message_Block::msg_deadline_time (void)"); @@ -279,7 +279,7 @@ ACE_Message_Block::access_allocators (ACE_Allocator *& allocator_strategy, } ACE_INLINE char * -ACE_Message_Block::base (void) const +ACE_Message_Block::base () const { ACE_TRACE ("ACE_Message_Block::base"); return this->data_block ()->base (); @@ -297,7 +297,7 @@ ACE_Message_Block::base (char *msg_data, } ACE_INLINE char * -ACE_Message_Block::rd_ptr (void) const +ACE_Message_Block::rd_ptr () const { ACE_TRACE ("ACE_Message_Block::rd_ptr"); return this->base () + this->rd_ptr_; @@ -313,28 +313,28 @@ ACE_Message_Block::wr_ptr (char *new_ptr) // Return a pointer to 1 past the end of the data buffer. ACE_INLINE char * -ACE_Data_Block::mark (void) const +ACE_Data_Block::mark () const { ACE_TRACE ("ACE_Data_Block::mark"); return this->base_ + this->cur_size_; } ACE_INLINE char * -ACE_Message_Block::mark (void) const +ACE_Message_Block::mark () const { ACE_TRACE ("ACE_Message_Block::mark"); return this->data_block ()->mark (); } ACE_INLINE char * -ACE_Data_Block::end (void) const +ACE_Data_Block::end () const { ACE_TRACE ("ACE_Data_Block::end"); return this->base_ + this->max_size_; } ACE_INLINE char * -ACE_Message_Block::end (void) const +ACE_Message_Block::end () const { ACE_TRACE ("ACE_Message_Block::end"); return this->data_block ()->end (); @@ -356,7 +356,7 @@ ACE_Message_Block::rd_ptr (size_t n) } ACE_INLINE char * -ACE_Message_Block::wr_ptr (void) const +ACE_Message_Block::wr_ptr () const { ACE_TRACE ("ACE_Message_Block::wr_ptr"); return this->base () + this->wr_ptr_; @@ -370,7 +370,7 @@ ACE_Message_Block::wr_ptr (size_t n) } ACE_INLINE void -ACE_Message_Block::reset (void) +ACE_Message_Block::reset () { ACE_TRACE ("ACE_Message_Block::reset"); this->rd_ptr_ = 0; @@ -378,7 +378,7 @@ ACE_Message_Block::reset (void) } ACE_INLINE size_t -ACE_Message_Block::space (void) const +ACE_Message_Block::space () const { ACE_TRACE ("ACE_Message_Block::space"); return this->mark () - this->wr_ptr (); @@ -410,7 +410,7 @@ ACE_Message_Block::cont (ACE_Message_Block *cont_msg) } ACE_INLINE ACE_Message_Block * -ACE_Message_Block::cont (void) const +ACE_Message_Block::cont () const { ACE_TRACE ("ACE_Message_Block::cont"); return this->cont_; @@ -442,7 +442,7 @@ ACE_Message_Block::next (ACE_Message_Block *next_msg) } ACE_INLINE ACE_Message_Block * -ACE_Message_Block::next (void) const +ACE_Message_Block::next () const { ACE_TRACE ("ACE_Message_Block::next"); return this->next_; @@ -456,21 +456,21 @@ ACE_Message_Block::prev (ACE_Message_Block *next_msg) } ACE_INLINE ACE_Message_Block * -ACE_Message_Block::prev (void) const +ACE_Message_Block::prev () const { ACE_TRACE ("ACE_Message_Block::prev"); return this->prev_; } ACE_INLINE ACE_Allocator * -ACE_Data_Block::allocator_strategy (void) const +ACE_Data_Block::allocator_strategy () const { ACE_TRACE ("ACE_Data_Block::allocator_strategy"); return this->allocator_strategy_; } ACE_INLINE ACE_Lock * -ACE_Data_Block::locking_strategy (void) +ACE_Data_Block::locking_strategy () { ACE_TRACE ("ACE_Data_Block::locking_strategy"); return this->locking_strategy_; @@ -487,7 +487,7 @@ ACE_Data_Block::locking_strategy (ACE_Lock *nls) } ACE_INLINE ACE_Lock * -ACE_Message_Block::locking_strategy (void) +ACE_Message_Block::locking_strategy () { ACE_TRACE ("ACE_Message_Block::locking_strategy"); return this->data_block ()->locking_strategy (); diff --git a/ACE/ace/Message_Block_T.cpp b/ACE/ace/Message_Block_T.cpp index e4161efed1c..57a9923a257 100644 --- a/ACE/ace/Message_Block_T.cpp +++ b/ACE/ace/Message_Block_T.cpp @@ -12,7 +12,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class L> -ACE_Locked_Data_Block<L>::~ACE_Locked_Data_Block (void) +ACE_Locked_Data_Block<L>::~ACE_Locked_Data_Block () { } diff --git a/ACE/ace/Message_Block_T.h b/ACE/ace/Message_Block_T.h index eebb9408192..d2e854d82cd 100644 --- a/ACE/ace/Message_Block_T.h +++ b/ACE/ace/Message_Block_T.h @@ -37,7 +37,7 @@ class ACE_Locked_Data_Block : public ACE_Data_Block { public: /// Default "do-nothing" constructor. - ACE_Locked_Data_Block (void); + ACE_Locked_Data_Block (); /// Initialize. ACE_Locked_Data_Block (size_t size, @@ -48,7 +48,7 @@ public: ACE_Allocator *data_block_allocator); /// Delete all the resources held in the message. - virtual ~ACE_Locked_Data_Block (void); + virtual ~ACE_Locked_Data_Block (); /** * Return an exact "deep copy" of the message, the dynamic type is diff --git a/ACE/ace/Message_Block_T.inl b/ACE/ace/Message_Block_T.inl index cdc1b73872f..af729e9f450 100644 --- a/ACE/ace/Message_Block_T.inl +++ b/ACE/ace/Message_Block_T.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template<class ACE_LOCK> ACE_INLINE -ACE_Locked_Data_Block<ACE_LOCK>::ACE_Locked_Data_Block (void) +ACE_Locked_Data_Block<ACE_LOCK>::ACE_Locked_Data_Block () { this->locking_strategy_ = &this->lock_; } diff --git a/ACE/ace/Mutex.h b/ACE/ace/Mutex.h index 159f57da038..2f371a772a5 100644 --- a/ACE/ace/Mutex.h +++ b/ACE/ace/Mutex.h @@ -55,17 +55,17 @@ public: mode_t mode = ACE_DEFAULT_FILE_PERMS); /// Implicitly destroy the mutex. - ~ACE_Mutex (void); + ~ACE_Mutex (); /// Explicitly destroy the mutex. /** * @note Only one thread should call this method since it doesn't * protect against race conditions. */ - int remove (void); + int remove (); /// Acquire lock ownership (wait on queue if necessary). - int acquire (void); + int acquire (); /// Block the thread until the mutex is acquired or @a tv times out, /// in which case -1 is returned and @c errno == @c ETIME. @@ -94,24 +94,24 @@ public: * @return -1 on failure. If we "failed" because someone * else already had the lock, @c errno is set to @c EBUSY. */ - int tryacquire (void); + int tryacquire (); /// Release lock and unblock a thread at head of queue. - int release (void); + int release (); /// Acquire mutex ownership. /** * This calls @c acquire and is only here to make the @c ACE_Mutex * interface consistent with the other synchronization APIs. */ - int acquire_read (void); + int acquire_read (); /// Acquire mutex ownership. /** * This calls @c acquire and is only here to make the @c ACE_Mutex * interface consistent with the other synchronization APIs. */ - int acquire_write (void); + int acquire_write (); /// Conditionally acquire mutex (i.e., won't block). /** @@ -121,7 +121,7 @@ public: * @return -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 mutex (i.e., won't block). /** @@ -131,25 +131,25 @@ public: * @return -1 on failure. If we "failed" because someone else * already had the lock, @c errno is set to @c EBUSY. */ - int tryacquire_write (void); + int tryacquire_write (); /** * This is only here for consistency with the other synchronization * APIs and usability with Lock adapters. Assumes the caller already has * acquired the mutex and returns 0 in all cases. */ - int tryacquire_write_upgrade (void); + int tryacquire_write_upgrade (); /// Return the underlying mutex. - const ACE_mutex_t &lock (void) const; - ACE_mutex_t &lock (void); + const ACE_mutex_t &lock () const; + ACE_mutex_t &lock (); /// If a file was created as the underlying storage for the mutex, /// remove it from the filesystem (for process-shared mutexes). static int unlink (const ACE_TCHAR *name); /// 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/Mutex.inl b/ACE/ace/Mutex.inl index 42870709716..7adfceaa12c 100644 --- a/ACE/ace/Mutex.inl +++ b/ACE/ace/Mutex.inl @@ -9,7 +9,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int -ACE_Mutex::acquire_read (void) +ACE_Mutex::acquire_read () { // ACE_TRACE ("ACE_Mutex::acquire_read"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -23,7 +23,7 @@ ACE_Mutex::acquire_read (void) } ACE_INLINE int -ACE_Mutex::acquire_write (void) +ACE_Mutex::acquire_write () { // ACE_TRACE ("ACE_Mutex::acquire_write"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -37,7 +37,7 @@ ACE_Mutex::acquire_write (void) } ACE_INLINE int -ACE_Mutex::tryacquire_read (void) +ACE_Mutex::tryacquire_read () { // ACE_TRACE ("ACE_Mutex::tryacquire_read"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -51,7 +51,7 @@ ACE_Mutex::tryacquire_read (void) } ACE_INLINE const ACE_mutex_t & -ACE_Mutex::lock (void) const +ACE_Mutex::lock () const { // ACE_TRACE ("ACE_Mutex::lock"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -62,7 +62,7 @@ ACE_Mutex::lock (void) const } ACE_INLINE ACE_mutex_t & -ACE_Mutex::lock (void) +ACE_Mutex::lock () { // ACE_TRACE ("ACE_Mutex::lock"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -73,7 +73,7 @@ ACE_Mutex::lock (void) } ACE_INLINE int -ACE_Mutex::tryacquire_write (void) +ACE_Mutex::tryacquire_write () { // ACE_TRACE ("ACE_Mutex::tryacquire_write"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -87,14 +87,14 @@ ACE_Mutex::tryacquire_write (void) } ACE_INLINE int -ACE_Mutex::tryacquire_write_upgrade (void) +ACE_Mutex::tryacquire_write_upgrade () { // ACE_TRACE ("ACE_Mutex::tryacquire_write_upgrade"); return 0; } ACE_INLINE int -ACE_Mutex::acquire (void) +ACE_Mutex::acquire () { // ACE_TRACE ("ACE_Mutex::acquire"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -135,7 +135,7 @@ ACE_Mutex::acquire (ACE_Time_Value *tv) } ACE_INLINE int -ACE_Mutex::tryacquire (void) +ACE_Mutex::tryacquire () { // ACE_TRACE ("ACE_Mutex::tryacquire"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -149,7 +149,7 @@ ACE_Mutex::tryacquire (void) } ACE_INLINE int -ACE_Mutex::release (void) +ACE_Mutex::release () { // ACE_TRACE ("ACE_Mutex::release"); #ifdef ACE_MUTEX_PROCESS_LOCK_IS_MUTEX @@ -163,7 +163,7 @@ ACE_Mutex::release (void) } ACE_INLINE int -ACE_Mutex::remove (void) +ACE_Mutex::remove () { // ACE_TRACE ("ACE_Mutex::remove"); int result = 0; diff --git a/ACE/ace/Node.cpp b/ACE/ace/Node.cpp index f1ca0de37bb..b23dd0a9462 100644 --- a/ACE/ace/Node.cpp +++ b/ACE/ace/Node.cpp @@ -16,7 +16,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Node) template <class T, class C> -ACE_Node<T, C>::~ACE_Node (void) +ACE_Node<T, C>::~ACE_Node () { } diff --git a/ACE/ace/Node.h b/ACE/ace/Node.h index aecc69d83d1..d81e189d1f2 100644 --- a/ACE/ace/Node.h +++ b/ACE/ace/Node.h @@ -50,7 +50,7 @@ public: friend class ACE_Unbounded_Stack_Iterator<T>; /// This isn't necessary, but it keeps some compilers happy. - ~ACE_Node (void); + ~ACE_Node (); ACE_ALLOC_HOOK_DECLARE; diff --git a/ACE/ace/Null_Barrier.h b/ACE/ace/Null_Barrier.h index 50e4e2789ea..c1147907f4e 100644 --- a/ACE/ace/Null_Barrier.h +++ b/ACE/ace/Null_Barrier.h @@ -30,14 +30,14 @@ public: void * = 0) {}; /// Default dtor. - ~ACE_Null_Barrier (void) {}; + ~ACE_Null_Barrier () {}; /// Block the caller until all <count> threads have called <wait> and /// then allow all the caller threads to continue in parallel. - int wait (void) { return 0; }; + int wait () { return 0; }; /// 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/Null_Condition.h b/ACE/ace/Null_Condition.h index a86e0c54bec..bf4d4313a4e 100644 --- a/ACE/ace/Null_Condition.h +++ b/ACE/ace/Null_Condition.h @@ -49,10 +49,10 @@ public: void * = 0) : mutex_ ((ACE_Null_Mutex &) m) {} - ~ACE_Condition (void) {} + ~ACE_Condition () {} /// Returns 0. - int remove (void) {return 0;} + int remove () {return 0;} /// Returns -1 with @c errno == @c ETIME. int wait (const ACE_Time_Value * = 0) {errno = ETIME; return -1;} @@ -62,14 +62,14 @@ public: const ACE_Time_Value * = 0) {errno = ETIME; return -1;} /// Returns 0. - int signal (void) {return 0;} + int signal () {return 0;} /// Returns 0. - int broadcast (void) {return 0;} - ACE_Null_Mutex &mutex (void) {return this->mutex_;}; + int broadcast () {return 0;} + ACE_Null_Mutex &mutex () {return this->mutex_;}; /// Dump the state of an object. - void dump (void) const {} + void dump () const {} // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. diff --git a/ACE/ace/Null_Mutex.h b/ACE/ace/Null_Mutex.h index ef6269592cd..63d449ecd1e 100644 --- a/ACE/ace/Null_Mutex.h +++ b/ACE/ace/Null_Mutex.h @@ -38,12 +38,12 @@ class ACE_Export ACE_Null_Mutex public: ACE_Null_Mutex (const ACE_TCHAR * = 0) : lock_ (0) {} - ~ACE_Null_Mutex (void) {} + ~ACE_Null_Mutex () {} /// Return 0. - int remove (void) {return 0;} + int remove () {return 0;} /// Return 0. - int acquire (void) {return 0;} + int acquire () {return 0;} /// Return -1 with @c errno == @c ETIME. int acquire (ACE_Time_Value &) {errno = ETIME; return -1;} @@ -52,28 +52,28 @@ public: int acquire (ACE_Time_Value *) {errno = ETIME; return -1;} /// Return 0. - int tryacquire (void) {return 0;} + int tryacquire () {return 0;} /// Return 0. - int release (void) {return 0;} + int release () {return 0;} /// Return 0. - int acquire_write (void) {return 0;} + int acquire_write () {return 0;} /// Return 0. - int tryacquire_write (void) {return 0;} + int tryacquire_write () {return 0;} /// Return 0. - int tryacquire_write_upgrade (void) {return 0;} + int tryacquire_write_upgrade () {return 0;} /// Return 0. - int acquire_read (void) {return 0;} + int acquire_read () {return 0;} /// Return 0. - int tryacquire_read (void) {return 0;} + int tryacquire_read () {return 0;} /// Dump the state of an object. - void dump (void) const {} + void dump () const {} /// Declare the dynamic allocation hooks. //ACE_ALLOC_HOOK_DECLARE; @@ -106,13 +106,13 @@ public: ~ACE_Guard (void) {} #endif /* ACE_WIN32 */ - int acquire (void) { return 0; } - int tryacquire (void) { return 0; } - int release (void) { return 0; } - void disown (void) {} - int locked (void) { return 1; } - int remove (void) { return 0; } - void dump (void) const {} + int acquire () { return 0; } + int tryacquire () { return 0; } + int release () { return 0; } + void disown () {} + int locked () { return 1; } + int remove () { return 0; } + void dump () const {} private: ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &) = delete; @@ -138,11 +138,11 @@ public: ACE_Write_Guard (ACE_Null_Mutex &m, int blocked) : ACE_Guard<ACE_Null_Mutex> (m, blocked) {} - int acquire_write (void) { return 0; } - int acquire (void) { return 0; } - int tryacquire_write (void) { return 0; } - int tryacquire (void) { return 0; } - void dump (void) const {} + int acquire_write () { return 0; } + int acquire () { return 0; } + int tryacquire_write () { return 0; } + int tryacquire () { return 0; } + void dump () const {} }; template <class ACE_LOCK> @@ -162,11 +162,11 @@ public: ACE_Read_Guard (ACE_Null_Mutex &m, int blocked) : ACE_Guard<ACE_Null_Mutex> (m, blocked) {} - int acquire_read (void) { return 0; } - int acquire (void) { return 0; } - int tryacquire_read (void) { return 0; } - int tryacquire (void) { return 0; } - void dump (void) const {} + int acquire_read () { return 0; } + int acquire () { return 0; } + int tryacquire_read () { return 0; } + int tryacquire () { return 0; } + void dump () const {} }; // FUZZ: enable check_for_ACE_Guard diff --git a/ACE/ace/Null_Semaphore.h b/ACE/ace/Null_Semaphore.h index 3e35bdff291..8656098ead9 100644 --- a/ACE/ace/Null_Semaphore.h +++ b/ACE/ace/Null_Semaphore.h @@ -51,12 +51,12 @@ public: const ACE_TCHAR * = 0, void * = 0, int = 0x7fffffff) {} - ~ACE_Null_Semaphore (void) {} + ~ACE_Null_Semaphore () {} /// Return 0. - int remove (void) {return 0;} + int remove () {return 0;} /// Return 0. - int acquire (void) {return 0;} + int acquire () {return 0;} /// Return -1 with @c errno == @c ETIME. int acquire (ACE_Time_Value &) {errno = ETIME; return -1;} @@ -65,31 +65,31 @@ public: int acquire (ACE_Time_Value *) {errno = ETIME; return -1;} /// Return 0. - int tryacquire (void) {return 0;} + int tryacquire () {return 0;} /// Return 0. - int release (void) {return 0;} + int release () {return 0;} /// Return 0. int release (size_t) {return 0;} /// Return 0. - int acquire_write (void) {return 0;} + int acquire_write () {return 0;} /// Return 0. - int tryacquire_write (void) {return 0;} + int tryacquire_write () {return 0;} /// Return 0. - int tryacquire_write_upgrade (void) {return 0;} + int tryacquire_write_upgrade () {return 0;} /// Return 0. - int acquire_read (void) {return 0;} + int acquire_read () {return 0;} /// Return 0. - int tryacquire_read (void) {return 0;} + int tryacquire_read () {return 0;} /// 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/Numeric_Limits.h b/ACE/ace/Numeric_Limits.h index d8e7ca6adf4..b842ef71de9 100644 --- a/ACE/ace/Numeric_Limits.h +++ b/ACE/ace/Numeric_Limits.h @@ -210,8 +210,8 @@ struct ACE_Export ACE_Numeric_Limits<long double> template <typename T> struct ACE_Numeric_Limits { - static T min (void) { return std::numeric_limits<T>::min (); } - static T max (void) { return std::numeric_limits<T>::max (); } + static T min () { return std::numeric_limits<T>::min (); } + static T max () { return std::numeric_limits<T>::max (); } }; #endif /* ACE_LACKS_NUMERIC_LIMITS */ diff --git a/ACE/ace/OS_Errno.h b/ACE/ace/OS_Errno.h index be1a5eee3c3..de7d8420a4c 100644 --- a/ACE/ace/OS_Errno.h +++ b/ACE/ace/OS_Errno.h @@ -53,7 +53,7 @@ public: ACE_Errno_Guard (ACE_ERRNO_TYPE &errno_ref); /// Reset the value of @c errno to <error>. - ~ACE_Errno_Guard (void); + ~ACE_Errno_Guard (); #if defined (ACE_HAS_WINCE_BROKEN_ERRNO) /// Assign @a errno_ref to <error_>. diff --git a/ACE/ace/OS_Errno.inl b/ACE/ace/OS_Errno.inl index 9fd2af39b92..0a7fa0f4ff2 100644 --- a/ACE/ace/OS_Errno.inl +++ b/ACE/ace/OS_Errno.inl @@ -26,7 +26,7 @@ ACE_Errno_Guard::ACE_Errno_Guard (ACE_ERRNO_TYPE &errno_ref) } ACE_INLINE -ACE_Errno_Guard::~ACE_Errno_Guard (void) +ACE_Errno_Guard::~ACE_Errno_Guard () { #if defined (ACE_MT_SAFE) *errno_ptr_ = this->error_; diff --git a/ACE/ace/OS_Log_Msg_Attributes.h b/ACE/ace/OS_Log_Msg_Attributes.h index 6ef922b1ace..356c9a7b7f8 100644 --- a/ACE/ace/OS_Log_Msg_Attributes.h +++ b/ACE/ace/OS_Log_Msg_Attributes.h @@ -42,7 +42,7 @@ class ACE_Export ACE_OS_Log_Msg_Attributes { public: /// Constructor - ACE_OS_Log_Msg_Attributes (void); + ACE_OS_Log_Msg_Attributes (); protected: friend class ACE_Log_Msg; diff --git a/ACE/ace/OS_Log_Msg_Attributes.inl b/ACE/ace/OS_Log_Msg_Attributes.inl index 222609f53d8..744ac94870f 100644 --- a/ACE/ace/OS_Log_Msg_Attributes.inl +++ b/ACE/ace/OS_Log_Msg_Attributes.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_OS_Log_Msg_Attributes::ACE_OS_Log_Msg_Attributes (void) : +ACE_OS_Log_Msg_Attributes::ACE_OS_Log_Msg_Attributes () : ostream_ (0), ostream_refcount_ (0), priority_mask_ (0), diff --git a/ACE/ace/OS_NS_Thread.h b/ACE/ace/OS_NS_Thread.h index 98a24079307..e01e8a2b4f7 100644 --- a/ACE/ace/OS_NS_Thread.h +++ b/ACE/ace/OS_NS_Thread.h @@ -701,7 +701,7 @@ public: ACE_hthread_t thr_handle); /// Initialize the object using calls to ACE_OS::thr_self(). - ACE_Thread_ID (void); + ACE_Thread_ID (); /// Copy constructor. ACE_Thread_ID (const ACE_Thread_ID &id); @@ -710,13 +710,13 @@ public: ACE_Thread_ID& operator= (const ACE_Thread_ID &id); /// Get the thread id. - ACE_thread_t id (void) const; + ACE_thread_t id () const; /// Set the thread id. void id (ACE_thread_t); /// Get the thread handle. - ACE_hthread_t handle (void) const; + ACE_hthread_t handle () const; /// Set the thread handle. void handle (ACE_hthread_t); @@ -1629,7 +1629,7 @@ namespace ACE_OS { void thr_exit (ACE_THR_FUNC_RETURN status = 0); ACE_NAMESPACE_INLINE_FUNCTION - int thr_getconcurrency (void); + int thr_getconcurrency (); ACE_NAMESPACE_INLINE_FUNCTION int thr_getprio (ACE_hthread_t id, @@ -1740,16 +1740,16 @@ namespace ACE_OS { int thr_kill (ACE_thread_t thr_id, int signum); ACE_NAMESPACE_INLINE_FUNCTION - size_t thr_min_stack (void); + size_t thr_min_stack (); ACE_NAMESPACE_INLINE_FUNCTION - ACE_thread_t thr_self (void); + ACE_thread_t thr_self (); ACE_NAMESPACE_INLINE_FUNCTION void thr_self (ACE_hthread_t &); ACE_NAMESPACE_INLINE_FUNCTION - const char* thr_name (void); + const char* thr_name (); /// Stores a string version of the current thread id into buffer and /// returns the size of this thread id in bytes. @@ -1809,10 +1809,10 @@ namespace ACE_OS { int thr_suspend (ACE_hthread_t target_thread); ACE_NAMESPACE_INLINE_FUNCTION - void thr_testcancel (void); + void thr_testcancel (); ACE_NAMESPACE_INLINE_FUNCTION - void thr_yield (void); + void thr_yield (); //@{ @name A set of wrappers for mutex locks that only work within a single process. @@ -1952,17 +1952,17 @@ class ACE_Export ACE_event_t public: /// Constructor initializing all pointer fields to null - ACE_event_t (void); + ACE_event_t (); private: /// Lock the internal mutex/semaphore - int lock (void); + int lock (); /// Unlock the internal mutex/semaphore - int unlock (void); + int unlock (); /// Use the internal semaphore or condition variable to unblock one thread - int wake_one (void); + int wake_one (); /// Event name if process shared. char *name_; @@ -2014,13 +2014,13 @@ public: ACE_OS_Thread_Mutex_Guard (ACE_thread_mutex_t &m); /// Implicitly release the lock. - ~ACE_OS_Thread_Mutex_Guard (void); + ~ACE_OS_Thread_Mutex_Guard (); /// Explicitly acquire the lock. - int acquire (void); + int acquire (); /// Explicitly release the lock. - int release (void); + int release (); protected: /// Reference to the mutex. @@ -2059,13 +2059,13 @@ public: ACE_OS_Recursive_Thread_Mutex_Guard (ACE_recursive_thread_mutex_t &m); /// Implicitly release the lock. - ~ACE_OS_Recursive_Thread_Mutex_Guard (void); + ~ACE_OS_Recursive_Thread_Mutex_Guard (); /// Explicitly acquire the lock. - int acquire (void); + int acquire (); /// Explicitly release the lock. - int release (void); + int release (); protected: /// Reference to the mutex. diff --git a/ACE/ace/OS_NS_Thread.inl b/ACE/ace/OS_NS_Thread.inl index 8e1e1e94204..4b34fdeea11 100644 --- a/ACE/ace/OS_NS_Thread.inl +++ b/ACE/ace/OS_NS_Thread.inl @@ -2821,7 +2821,7 @@ ACE_OS::thr_continue (ACE_hthread_t target_thread) } ACE_INLINE int -ACE_OS::thr_getconcurrency (void) +ACE_OS::thr_getconcurrency () { ACE_OS_TRACE ("ACE_OS::thr_getconcurrency"); #if defined (ACE_HAS_THREADS) @@ -3108,7 +3108,7 @@ ACE_OS::thr_kill (ACE_thread_t thr_id, int signum) } ACE_INLINE size_t -ACE_OS::thr_min_stack (void) +ACE_OS::thr_min_stack () { ACE_OS_TRACE ("ACE_OS::thr_min_stack"); #if defined (ACE_HAS_THREADS) @@ -3180,7 +3180,7 @@ ACE_OS::thr_gettid (char buffer[], size_t buffer_length) } ACE_INLINE ACE_thread_t -ACE_OS::thr_self (void) +ACE_OS::thr_self () { // ACE_OS_TRACE ("ACE_OS::thr_self"); #if defined (ACE_HAS_THREADS) @@ -3200,7 +3200,7 @@ ACE_OS::thr_self (void) } ACE_INLINE const char* -ACE_OS::thr_name (void) +ACE_OS::thr_name () { #if defined (ACE_HAS_THREADS) #if defined (ACE_HAS_VXTHREADS) @@ -3555,7 +3555,7 @@ ACE_OS::thr_suspend (ACE_hthread_t target_thread) } ACE_INLINE void -ACE_OS::thr_testcancel (void) +ACE_OS::thr_testcancel () { ACE_OS_TRACE ("ACE_OS::thr_testcancel"); #if defined (ACE_HAS_THREADS) @@ -3572,7 +3572,7 @@ ACE_OS::thr_testcancel (void) } ACE_INLINE void -ACE_OS::thr_yield (void) +ACE_OS::thr_yield () { ACE_OS_TRACE ("ACE_OS::thr_yield"); #if defined (ACE_HAS_THREADS) @@ -3800,14 +3800,14 @@ ACE_OS::thread_mutex_unlock (ACE_thread_mutex_t *m) ACE_INLINE int -ACE_OS_Thread_Mutex_Guard::acquire (void) +ACE_OS_Thread_Mutex_Guard::acquire () { return owner_ = ACE_OS::thread_mutex_lock (&lock_); } ACE_INLINE int -ACE_OS_Thread_Mutex_Guard::release (void) +ACE_OS_Thread_Mutex_Guard::release () { if (owner_ == -1) return 0; @@ -3836,14 +3836,14 @@ ACE_OS_Thread_Mutex_Guard::~ACE_OS_Thread_Mutex_Guard () ACE_INLINE int -ACE_OS_Recursive_Thread_Mutex_Guard::acquire (void) +ACE_OS_Recursive_Thread_Mutex_Guard::acquire () { return owner_ = ACE_OS::recursive_mutex_lock (&lock_); } ACE_INLINE int -ACE_OS_Recursive_Thread_Mutex_Guard::release (void) +ACE_OS_Recursive_Thread_Mutex_Guard::release () { if (owner_ == -1) return 0; @@ -3903,7 +3903,7 @@ ACE_Thread_ID::operator= (const ACE_Thread_ID &id) } ACE_INLINE -ACE_Thread_ID::ACE_Thread_ID (void) +ACE_Thread_ID::ACE_Thread_ID () : thread_id_ (ACE_OS::thr_self ()) { ACE_OS::thr_self (thread_handle_); @@ -3911,7 +3911,7 @@ ACE_Thread_ID::ACE_Thread_ID (void) ACE_INLINE ACE_thread_t -ACE_Thread_ID::id (void) const +ACE_Thread_ID::id () const { return this->thread_id_; } @@ -3923,7 +3923,7 @@ ACE_Thread_ID::id (ACE_thread_t thread_id) } ACE_INLINE ACE_hthread_t -ACE_Thread_ID::handle (void) const +ACE_Thread_ID::handle () const { return this->thread_handle_; } @@ -3951,7 +3951,7 @@ ACE_Thread_ID::operator!= (const ACE_Thread_ID &rhs) const #if !defined (ACE_WIN32) ACE_INLINE -ACE_event_t::ACE_event_t (void) : +ACE_event_t::ACE_event_t () : name_ (0), eventdata_ (0) { diff --git a/ACE/ace/OS_NS_errno.h b/ACE/ace/OS_NS_errno.h index a240a7fa9ff..407f68a2ee0 100644 --- a/ACE/ace/OS_NS_errno.h +++ b/ACE/ace/OS_NS_errno.h @@ -36,16 +36,16 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL namespace ACE_OS { ACE_NAMESPACE_INLINE_FUNCTION - int last_error (void); + int last_error (); ACE_NAMESPACE_INLINE_FUNCTION void last_error (int error); ACE_NAMESPACE_INLINE_FUNCTION - int set_errno_to_last_error (void); + int set_errno_to_last_error (); ACE_NAMESPACE_INLINE_FUNCTION - int set_errno_to_wsa_last_error (void); + int set_errno_to_wsa_last_error (); #ifdef ACE_MQX int mqx_error_to_errno(int mqx_error); diff --git a/ACE/ace/OS_NS_errno.inl b/ACE/ace/OS_NS_errno.inl index cad5d49789b..408039c5526 100644 --- a/ACE/ace/OS_NS_errno.inl +++ b/ACE/ace/OS_NS_errno.inl @@ -4,7 +4,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int -ACE_OS::last_error (void) +ACE_OS::last_error () { // ACE_OS_TRACE ("ACE_OS::last_error"); @@ -33,7 +33,7 @@ ACE_OS::last_error (int error) } ACE_INLINE int -ACE_OS::set_errno_to_last_error (void) +ACE_OS::set_errno_to_last_error () { # if defined (ACE_WIN32) return errno = ::GetLastError (); @@ -43,7 +43,7 @@ ACE_OS::set_errno_to_last_error (void) } ACE_INLINE int -ACE_OS::set_errno_to_wsa_last_error (void) +ACE_OS::set_errno_to_wsa_last_error () { # if defined (ACE_WIN32) return errno = ::WSAGetLastError (); diff --git a/ACE/ace/OS_NS_pwd.h b/ACE/ace/OS_NS_pwd.h index 4bdaf900107..86b91883639 100644 --- a/ACE/ace/OS_NS_pwd.h +++ b/ACE/ace/OS_NS_pwd.h @@ -40,10 +40,10 @@ namespace ACE_OS //@{ @name A set of wrappers for password routines. ACE_NAMESPACE_INLINE_FUNCTION - void endpwent (void); + void endpwent (); ACE_NAMESPACE_INLINE_FUNCTION - struct passwd *getpwent (void); + struct passwd *getpwent (); ACE_NAMESPACE_INLINE_FUNCTION struct passwd *getpwnam (const char *user); @@ -56,7 +56,7 @@ namespace ACE_OS struct passwd **result); ACE_NAMESPACE_INLINE_FUNCTION - void setpwent (void); + void setpwent (); //@} } /* namespace ACE_OS */ diff --git a/ACE/ace/OS_NS_pwd.inl b/ACE/ace/OS_NS_pwd.inl index 3d680bba97b..ed75cfdc961 100644 --- a/ACE/ace/OS_NS_pwd.inl +++ b/ACE/ace/OS_NS_pwd.inl @@ -6,7 +6,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL // Accessors to PWD file. ACE_INLINE void -ACE_OS::endpwent (void) +ACE_OS::endpwent () { #if !defined (ACE_LACKS_PWD_FUNCTIONS) ::endpwent (); @@ -14,7 +14,7 @@ ACE_OS::endpwent (void) } ACE_INLINE struct passwd * -ACE_OS::getpwent (void) +ACE_OS::getpwent () { #if !defined (ACE_LACKS_PWD_FUNCTIONS) return ::getpwent (); @@ -70,7 +70,7 @@ ACE_OS::getpwnam_r (const char *name, } ACE_INLINE void -ACE_OS::setpwent (void) +ACE_OS::setpwent () { #if !defined (ACE_LACKS_PWD_FUNCTIONS) ::setpwent (); diff --git a/ACE/ace/OS_NS_stdio.h b/ACE/ace/OS_NS_stdio.h index a7705077d04..68a7b56a0cd 100644 --- a/ACE/ace/OS_NS_stdio.h +++ b/ACE/ace/OS_NS_stdio.h @@ -189,7 +189,7 @@ namespace ACE_OS { { public: /// Dump state of the object. - void dump (void) const; + void dump () const; # if defined (ACE_WIN32) ACE_OVERLAPPED overlapped_; diff --git a/ACE/ace/OS_NS_stdlib.h b/ACE/ace/OS_NS_stdlib.h index ef50095ccf5..0b682b7485f 100644 --- a/ACE/ace/OS_NS_stdlib.h +++ b/ACE/ace/OS_NS_stdlib.h @@ -103,7 +103,7 @@ namespace ACE_OS { void _exit (int status = 0) ACE_GCC_NO_RETURN; ACE_NAMESPACE_INLINE_FUNCTION - void abort (void) ACE_GCC_NO_RETURN; + void abort () ACE_GCC_NO_RETURN; /** * Register an at exit hook. The @a name can be used to analyze shutdown @@ -195,7 +195,7 @@ namespace ACE_OS { // not in spec extern ACE_Export - ACE_TCHAR *getenvstrings (void); + ACE_TCHAR *getenvstrings (); // itoa not in spec /// Converts an integer to a string. @@ -276,7 +276,7 @@ namespace ACE_OS { int unsetenv(const char *name); ACE_NAMESPACE_INLINE_FUNCTION - int rand (void); + int rand (); ACE_NAMESPACE_INLINE_FUNCTION int rand_r (unsigned int *seed); diff --git a/ACE/ace/OS_NS_stdlib.inl b/ACE/ace/OS_NS_stdlib.inl index 6e15308e442..356b258ae69 100644 --- a/ACE/ace/OS_NS_stdlib.inl +++ b/ACE/ace/OS_NS_stdlib.inl @@ -37,7 +37,7 @@ ACE_OS::_exit (int status) } ACE_INLINE void -ACE_OS::abort (void) +ACE_OS::abort () { #if defined (ACE_ANDROID) && (__ANDROID_API__ < 19) ACE_OS::_exit (128 + SIGABRT); @@ -407,7 +407,7 @@ ACE_OS::qsort (void *base, } ACE_INLINE int -ACE_OS::rand (void) +ACE_OS::rand () { ACE_OS_TRACE ("ACE_OS::rand"); #if !defined (ACE_LACKS_RAND) diff --git a/ACE/ace/OS_NS_sys_socket.h b/ACE/ace/OS_NS_sys_socket.h index faa6cd9bdfb..757a3bb1cd1 100644 --- a/ACE/ace/OS_NS_sys_socket.h +++ b/ACE/ace/OS_NS_sys_socket.h @@ -281,7 +281,7 @@ namespace ACE_OS char *if_indextoname (unsigned int ifindex, char *ifname); ACE_NAMESPACE_INLINE_FUNCTION - struct if_nameindex *if_nameindex (void); + struct if_nameindex *if_nameindex (); ACE_NAMESPACE_INLINE_FUNCTION void if_freenameindex (struct if_nameindex *ptr); @@ -294,7 +294,7 @@ namespace ACE_OS /// Finalize WinSock after last use (e.g., when a DLL is unloaded). extern ACE_Export - int socket_fini (void); + int socket_fini (); /// Create a BSD-style socket (no QoS). ACE_NAMESPACE_INLINE_FUNCTION diff --git a/ACE/ace/OS_NS_sys_socket.inl b/ACE/ace/OS_NS_sys_socket.inl index 3da4104198e..53036af3b8f 100644 --- a/ACE/ace/OS_NS_sys_socket.inl +++ b/ACE/ace/OS_NS_sys_socket.inl @@ -1046,7 +1046,7 @@ ACE_OS::if_indextoname (unsigned int ifindex, char *ifname) } ACE_INLINE struct if_nameindex * -ACE_OS::if_nameindex (void) +ACE_OS::if_nameindex () { ACE_OS_TRACE ("ACE_OS::if_nameindex"); #ifdef ACE_LACKS_IF_NAMEINDEX diff --git a/ACE/ace/OS_NS_sys_time.h b/ACE/ace/OS_NS_sys_time.h index 02d63331478..f873d1044e7 100644 --- a/ACE/ace/OS_NS_sys_time.h +++ b/ACE/ace/OS_NS_sys_time.h @@ -36,10 +36,10 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL namespace ACE_OS { ACE_NAMESPACE_INLINE_FUNCTION - ACE_Time_Value gettimeofday (void); + ACE_Time_Value gettimeofday (); ACE_NAMESPACE_INLINE_FUNCTION - ACE_Time_Value gettimeofday_ (void); + ACE_Time_Value gettimeofday_ (); } /* namespace ACE_OS */ ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/OS_NS_sys_time.inl b/ACE/ace/OS_NS_sys_time.inl index 488e6a1f205..1f7efda9fcb 100644 --- a/ACE/ace/OS_NS_sys_time.inl +++ b/ACE/ace/OS_NS_sys_time.inl @@ -9,7 +9,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Time_Value -ACE_OS::gettimeofday (void) +ACE_OS::gettimeofday () { // ACE_OS_TRACE ("ACE_OS::gettimeofday"); @@ -81,7 +81,7 @@ ACE_OS::gettimeofday (void) } ACE_INLINE ACE_Time_Value -ACE_OS::gettimeofday_ (void) +ACE_OS::gettimeofday_ () { return ACE_OS::gettimeofday (); } diff --git a/ACE/ace/OS_NS_time.h b/ACE/ace/OS_NS_time.h index 867336e7e19..a6c1f40dc21 100644 --- a/ACE/ace/OS_NS_time.h +++ b/ACE/ace/OS_NS_time.h @@ -293,11 +293,11 @@ namespace ACE_OS time_t time (time_t *tloc = 0); ACE_NAMESPACE_INLINE_FUNCTION - long timezone (void); + long timezone (); // wrapper for time zone information. ACE_NAMESPACE_INLINE_FUNCTION - void tzset (void); + void tzset (); //@} } /* namespace ACE_OS */ diff --git a/ACE/ace/OS_NS_time.inl b/ACE/ace/OS_NS_time.inl index 6bd482761ea..2214a6c873d 100644 --- a/ACE/ace/OS_NS_time.inl +++ b/ACE/ace/OS_NS_time.inl @@ -470,7 +470,7 @@ ACE_OS::time (time_t *tloc) #if defined (__GNUG__) namespace ACE_OS { ACE_INLINE long - timezone (void) + timezone () { return ::ace_timezone (); } @@ -484,7 +484,7 @@ ACE_OS::timezone (void) #endif /* ACE_LINUX */ ACE_INLINE void -ACE_OS::tzset (void) +ACE_OS::tzset () { #if defined (ACE_LACKS_TZSET) errno = ENOTSUP; diff --git a/ACE/ace/OS_NS_unistd.h b/ACE/ace/OS_NS_unistd.h index 460d767d90f..091cc708452 100644 --- a/ACE/ace/OS_NS_unistd.h +++ b/ACE/ace/OS_NS_unistd.h @@ -51,7 +51,7 @@ namespace ACE_OS unsigned int alarm (u_int secs); ACE_NAMESPACE_INLINE_FUNCTION - long allocation_granularity (void); + long allocation_granularity (); /// used by ARGV::argv_to_string() and ACE_OS::fork_exec() extern ACE_Export @@ -125,7 +125,7 @@ namespace ACE_OS /// Forks and exec's a process in a manner that works on Solaris and /// NT. argv[0] must be the full path name to the executable. ACE_NAMESPACE_INLINE_FUNCTION - pid_t fork (void); + pid_t fork (); // not in susv3 extern ACE_Export @@ -150,10 +150,10 @@ namespace ACE_OS #endif /* ACE_HAS_WCHAR */ ACE_NAMESPACE_INLINE_FUNCTION - gid_t getgid (void); + gid_t getgid (); ACE_NAMESPACE_INLINE_FUNCTION - gid_t getegid (void); + gid_t getegid (); ACE_NAMESPACE_INLINE_FUNCTION int getopt (int argc, @@ -161,22 +161,22 @@ namespace ACE_OS const char *optstring); ACE_NAMESPACE_INLINE_FUNCTION - long getpagesize (void); + long getpagesize (); ACE_NAMESPACE_INLINE_FUNCTION pid_t getpgid (pid_t pid); ACE_NAMESPACE_INLINE_FUNCTION - pid_t getpid (void); + pid_t getpid (); ACE_NAMESPACE_INLINE_FUNCTION - pid_t getppid (void); + pid_t getppid (); ACE_NAMESPACE_INLINE_FUNCTION - uid_t getuid (void); + uid_t getuid (); ACE_NAMESPACE_INLINE_FUNCTION - uid_t geteuid (void); + uid_t geteuid (); // should call gethostname() ACE_NAMESPACE_INLINE_FUNCTION @@ -211,11 +211,11 @@ namespace ACE_OS /// Get the number of CPUs configured in the machine. extern ACE_Export - long num_processors (void); + long num_processors (); /// Get the number of CPUs currently online. extern ACE_Export - long num_processors_online (void); + long num_processors_online (); ACE_NAMESPACE_INLINE_FUNCTION int pipe (ACE_HANDLE handles[]); @@ -281,7 +281,7 @@ namespace ACE_OS int setreuid (uid_t ruid, uid_t euid); ACE_NAMESPACE_INLINE_FUNCTION - pid_t setsid (void); + pid_t setsid (); ACE_NAMESPACE_INLINE_FUNCTION int setuid (uid_t); diff --git a/ACE/ace/OS_NS_unistd.inl b/ACE/ace/OS_NS_unistd.inl index 035f19baf11..bb29b1cfcee 100644 --- a/ACE/ace/OS_NS_unistd.inl +++ b/ACE/ace/OS_NS_unistd.inl @@ -94,7 +94,7 @@ ACE_OS::alarm (u_int secs) } ACE_INLINE long -ACE_OS::getpagesize (void) +ACE_OS::getpagesize () { ACE_OS_TRACE ("ACE_OS::getpagesize"); #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP) @@ -112,7 +112,7 @@ ACE_OS::getpagesize (void) } ACE_INLINE long -ACE_OS::allocation_granularity (void) +ACE_OS::allocation_granularity () { #if defined (ACE_WIN32) SYSTEM_INFO sys_info; @@ -361,7 +361,7 @@ ACE_OS::execvp (const char *file, } ACE_INLINE pid_t -ACE_OS::fork (void) +ACE_OS::fork () { ACE_OS_TRACE ("ACE_OS::fork"); #if defined (ACE_LACKS_FORK) @@ -451,7 +451,7 @@ ACE_OS::getcwd (wchar_t *buf, size_t size) #endif /* ACE_HAS_WCHAR */ ACE_INLINE gid_t -ACE_OS::getgid (void) +ACE_OS::getgid () { ACE_OS_TRACE ("ACE_OS::getgid"); #if defined (ACE_LACKS_GETGID) @@ -462,7 +462,7 @@ ACE_OS::getgid (void) } ACE_INLINE gid_t -ACE_OS::getegid (void) +ACE_OS::getegid () { ACE_OS_TRACE ("ACE_OS::getegid"); #if defined (ACE_LACKS_GETEGID) @@ -505,7 +505,7 @@ ACE_OS::getpgid (pid_t pid) } ACE_INLINE pid_t -ACE_OS::getpid (void) +ACE_OS::getpid () { // ACE_OS_TRACE ("ACE_OS::getpid"); #if defined (ACE_LACKS_GETPID) @@ -518,7 +518,7 @@ ACE_OS::getpid (void) } ACE_INLINE pid_t -ACE_OS::getppid (void) +ACE_OS::getppid () { ACE_OS_TRACE ("ACE_OS::getppid"); #if defined (ACE_LACKS_GETPPID) @@ -529,7 +529,7 @@ ACE_OS::getppid (void) } ACE_INLINE uid_t -ACE_OS::getuid (void) +ACE_OS::getuid () { ACE_OS_TRACE ("ACE_OS::getuid"); #if defined (ACE_LACKS_GETUID) @@ -540,7 +540,7 @@ ACE_OS::getuid (void) } ACE_INLINE uid_t -ACE_OS::geteuid (void) +ACE_OS::geteuid () { ACE_OS_TRACE ("ACE_OS::geteuid"); #if defined (ACE_LACKS_GETEUID) @@ -931,7 +931,7 @@ ACE_OS::setreuid (uid_t ruid, uid_t euid) } ACE_INLINE pid_t -ACE_OS::setsid (void) +ACE_OS::setsid () { ACE_OS_TRACE ("ACE_OS::setsid"); #if defined (ACE_LACKS_SETSID) diff --git a/ACE/ace/OS_QoS.h b/ACE/ace/OS_QoS.h index 3173eadba0c..e84c633b806 100644 --- a/ACE/ace/OS_QoS.h +++ b/ACE/ace/OS_QoS.h @@ -165,7 +165,7 @@ class ACE_Export ACE_Flow_Spec { public: /// Default constructor. - ACE_Flow_Spec (void); + ACE_Flow_Spec (); /// Constructor that initializes all the fields. ACE_Flow_Spec (unsigned long token_rate, @@ -180,61 +180,61 @@ public: int priority); /// Get the token rate in bytes/sec. - unsigned long token_rate (void) const; + unsigned long token_rate () const; /// Set the token rate in bytes/sec. void token_rate (unsigned long tr); /// Get the token bucket size in bytes. - unsigned long token_bucket_size (void) const; + unsigned long token_bucket_size () const; /// Set the token bucket size in bytes. void token_bucket_size (unsigned long tbs); /// Get the PeakBandwidth in bytes/sec. - unsigned long peak_bandwidth (void) const; + unsigned long peak_bandwidth () const; /// Set the PeakBandwidth in bytes/sec. void peak_bandwidth (unsigned long pb); /// Get the latency in microseconds. - unsigned long latency (void) const; + unsigned long latency () const; /// Set the latency in microseconds. void latency (unsigned long l); /// Get the delay variation in microseconds. - unsigned long delay_variation (void) const; + unsigned long delay_variation () const; /// Set the delay variation in microseconds. void delay_variation (unsigned long dv); /// Get the service type. - ACE_SERVICE_TYPE service_type (void) const; + ACE_SERVICE_TYPE service_type () const; /// Set the service type. void service_type (ACE_SERVICE_TYPE st); /// Get the maximum SDU size in bytes. - unsigned long max_sdu_size (void) const; + unsigned long max_sdu_size () const; /// Set the maximum SDU size in bytes. void max_sdu_size (unsigned long mss); /// Get the minimum policed size in bytes. - unsigned long minimum_policed_size (void) const; + unsigned long minimum_policed_size () const; /// Set the minimum policed size in bytes. void minimum_policed_size (unsigned long mps); /// Get the time-to-live. - int ttl (void) const; + int ttl () const; /// Set the time-to-live. void ttl (int t); /// Get the priority. - int priority (void) const; + int priority () const; /// Set the priority. void priority (int p); @@ -270,22 +270,22 @@ class ACE_Export ACE_QoS { public: /// Constructor - ACE_QoS (void); + ACE_QoS (); /// Get the flow spec for data sending. - ACE_Flow_Spec *sending_flowspec (void) const; + ACE_Flow_Spec *sending_flowspec () const; /// Set the flow spec for data sending. void sending_flowspec (ACE_Flow_Spec *fs); /// Get the flow spec for data receiving. - ACE_Flow_Spec *receiving_flowspec (void) const; + ACE_Flow_Spec *receiving_flowspec () const; /// Set the flow spec for data receiving. void receiving_flowspec (ACE_Flow_Spec *fs); /// Get the provider specific information. - iovec provider_specific (void) const; + iovec provider_specific () const; /// Set the provider specific information. void provider_specific (const iovec &ps); @@ -327,31 +327,31 @@ public: unsigned long flags = 0); /// Get caller data. - iovec *caller_data (void) const; + iovec *caller_data () const; /// Set caller data. void caller_data (iovec *); /// Get callee data. - iovec *callee_data (void) const; + iovec *callee_data () const; /// Set callee data. void callee_data (iovec *); /// Get socket qos. - ACE_QoS *socket_qos (void) const; + ACE_QoS *socket_qos () const; /// Set socket qos. void socket_qos (ACE_QoS *); /// Get group socket qos. - ACE_QoS *group_socket_qos (void) const; + ACE_QoS *group_socket_qos () const; /// Set group socket qos. void group_socket_qos (ACE_QoS *); /// Get flags. - unsigned long flags (void) const; + unsigned long flags () const; /// Set flags. void flags (unsigned long); @@ -412,13 +412,13 @@ public: unsigned long callback_data = 0); /// Get QoS condition callback. - ACE_QOS_CONDITION_FUNC qos_condition_callback (void) const; + ACE_QOS_CONDITION_FUNC qos_condition_callback () const; /// Set QoS condition callback. void qos_condition_callback (ACE_QOS_CONDITION_FUNC qcc); /// Get callback data. - unsigned long callback_data (void) const; + unsigned long callback_data () const; /// Set callback data. void callback_data (unsigned long cd); diff --git a/ACE/ace/Object_Manager.h b/ACE/ace/Object_Manager.h index 9a7c0b823b4..3f571874587 100644 --- a/ACE/ace/Object_Manager.h +++ b/ACE/ace/Object_Manager.h @@ -204,14 +204,14 @@ public: * ACE_Object_Manager. Returns 0 on success, -1 on failure, and 1 * if it had already been called. */ - virtual int init (void); + virtual int init (); /** * Explicitly destroy the singleton instance of the * ACE_Object_Manager. Returns 0 on success, -1 on failure, and 1 * if it had already been called. */ - virtual int fini (void); + virtual int fini (); /** * Returns 1 before the ACE_Object_Manager has been constructed. @@ -222,7 +222,7 @@ public: * this flag returns 0, if ACE_HAS_NONSTATIC_OBJECT_MANAGER is not * defined.) */ - static int starting_up (void); + static int starting_up (); /** * Returns 1 after the ACE_Object_Manager has been destroyed. This @@ -231,7 +231,7 @@ public: * some static objects before this flag can return 1, if * ACE_HAS_NONSTATIC_OBJECT_MANAGER is not defined.) */ - static int shutting_down (void); + static int shutting_down (); /** * Register an ACE_Cleanup object for cleanup at process @@ -332,7 +332,7 @@ public: * in ACE_Sig_Guard methods. * Deprecated: use ACE_Object_Manager::default_mask () instead. */ - static ACE_Sig_Set &default_mask (void); + static ACE_Sig_Set &default_mask (); private: /// For at_exit support. @@ -403,7 +403,7 @@ public: * are provided in the interface, this should not be public. However, * it is public so that ACE_Managed_Object<TYPE> can access it. */ - static ACE_Object_Manager *instance (void); + static ACE_Object_Manager *instance (); /// Table of preallocated objects. static void *preallocated_object[ACE_PREALLOCATED_OBJECTS]; @@ -416,8 +416,8 @@ public: /// hidden here. They're public so that the ACE_Object_Manager can /// be constructed/destructed in <main> with /// ACE_HAS_NONSTATIC_OBJECT_MANAGER. - ACE_Object_Manager (void); - ~ACE_Object_Manager (void); + ACE_Object_Manager (); + ~ACE_Object_Manager (); private: /// Singleton pointer. diff --git a/ACE/ace/Object_Manager.inl b/ACE/ace/Object_Manager.inl index a65098a6fa0..bd27ee65a87 100644 --- a/ACE/ace/Object_Manager.inl +++ b/ACE/ace/Object_Manager.inl @@ -37,7 +37,7 @@ ACE_Object_Manager::remove_at_exit (void *object) ACE_INLINE ACE_Sig_Set & -ACE_Object_Manager::default_mask (void) +ACE_Object_Manager::default_mask () { // A safe cast, but this static method shouldn't be used anyways. // Use ACE_Object_Manager::default_mask () instead. diff --git a/ACE/ace/Object_Manager_Base.h b/ACE/ace/Object_Manager_Base.h index 10daa17895d..a1758e0a616 100644 --- a/ACE/ace/Object_Manager_Base.h +++ b/ACE/ace/Object_Manager_Base.h @@ -47,10 +47,10 @@ class ACE_Export ACE_Object_Manager_Base { protected: /// Default constructor. - ACE_Object_Manager_Base (void); + ACE_Object_Manager_Base (); /// Destructor. - virtual ~ACE_Object_Manager_Base (void); + virtual ~ACE_Object_Manager_Base (); public: /** @@ -58,14 +58,14 @@ public: * to dynamic allocation failure (in which case errno is set to * ENOMEM), or 1 if it had already been called. */ - virtual int init (void) = 0; + virtual int init () = 0; /** * Explicitly destroy. Returns 0 on success, -1 on failure because * the number of fini () calls hasn't reached the number of init () * calls, or 1 if it had already been called. */ - virtual int fini (void) = 0; + virtual int fini () = 0; enum Object_Manager_State { @@ -86,7 +86,7 @@ protected: * this flag returns 0, if ACE_HAS_NONSTATIC_OBJECT_MANAGER is not * defined.) */ - int starting_up_i (void); + int starting_up_i (); /** * Returns 1 after ACE_Object_Manager_Base has been destroyed. This @@ -95,7 +95,7 @@ protected: * some static objects before this flag can return 1, if * ACE_HAS_NONSTATIC_OBJECT_MANAGER is not defined.) */ - int shutting_down_i (void); + int shutting_down_i (); /// State of the Object_Manager; Object_Manager_State object_manager_state_; @@ -129,21 +129,21 @@ public: ACE_ALLOC_HOOK_DECLARE; /// Explicitly initialize. - virtual int init (void); + virtual int init (); /// Explicitly destroy. - virtual int fini (void); + virtual int fini (); /** * Returns 1 before the ACE_OS_Object_Manager has been * constructed. See <ACE_Object_Manager::starting_up> for more * information. */ - static int starting_up (void); + static int starting_up (); /// Returns 1 after the ACE_OS_Object_Manager has been destroyed. /// See <ACE_Object_Manager::shutting_down> for more information. - static int shutting_down (void); + static int shutting_down (); /// Unique identifiers for preallocated objects. enum Preallocated_Object @@ -171,10 +171,10 @@ public: /// Accesses a default signal set used, for example, in /// ACE_Sig_Guard methods. - static sigset_t *default_mask (void); + static sigset_t *default_mask (); /// Returns the current thread hook for the process. - static ACE_Thread_Hook *thread_hook (void); + static ACE_Thread_Hook *thread_hook (); /// Returns the existing thread hook and assign a <new_thread_hook>. static ACE_Thread_Hook *thread_hook (ACE_Thread_Hook *new_thread_hook); @@ -195,13 +195,13 @@ public: // constructed/destructed in <main> with // <ACE_HAS_NONSTATIC_OBJECT_MANAGER>. /// Constructor. - ACE_OS_Object_Manager (void); + ACE_OS_Object_Manager (); /// Destructor. - ~ACE_OS_Object_Manager (void); + ~ACE_OS_Object_Manager (); /// Accessor to singleton instance. - static ACE_OS_Object_Manager *instance (void); + static ACE_OS_Object_Manager *instance (); /// For <ACE_OS::atexit> support. int at_exit (ACE_EXIT_HOOK func, const char* name = 0); diff --git a/ACE/ace/Pair_T.h b/ACE/ace/Pair_T.h index 6f60ed76ed7..36c32500e37 100644 --- a/ACE/ace/Pair_T.h +++ b/ACE/ace/Pair_T.h @@ -41,10 +41,10 @@ public: ACE_Reference_Pair (T1 &t1, T2 &t2); /// Access first. - T1 &first (void) const; + T1 &first () const; /// Access second. - T2 &second (void) const; + T2 &second () const; // Compare pairs. bool operator== (const ACE_Reference_Pair<T1, T2> &rhs) const; diff --git a/ACE/ace/Pair_T.inl b/ACE/ace/Pair_T.inl index a8f620350f6..bb7f763633d 100644 --- a/ACE/ace/Pair_T.inl +++ b/ACE/ace/Pair_T.inl @@ -10,13 +10,13 @@ ACE_Reference_Pair<T1, T2>::ACE_Reference_Pair (T1 &t1, } template <class T1, class T2> ACE_INLINE T1 & -ACE_Reference_Pair<T1, T2>::first (void) const +ACE_Reference_Pair<T1, T2>::first () const { return this->first_; } template <class T1, class T2> ACE_INLINE T2 & -ACE_Reference_Pair<T1, T2>::second (void) const +ACE_Reference_Pair<T1, T2>::second () const { return this->second_; } diff --git a/ACE/ace/RB_Tree.cpp b/ACE/ace/RB_Tree.cpp index 0c8c2a713b6..b953a0e6cbe 100644 --- a/ACE/ace/RB_Tree.cpp +++ b/ACE/ace/RB_Tree.cpp @@ -40,7 +40,7 @@ ACE_RB_Tree_Node<EXT_ID, INT_ID>::ACE_RB_Tree_Node (const EXT_ID &k, const INT_I // Destructor. template <class EXT_ID, class INT_ID> -ACE_RB_Tree_Node<EXT_ID, INT_ID>::~ACE_RB_Tree_Node (void) +ACE_RB_Tree_Node<EXT_ID, INT_ID>::~ACE_RB_Tree_Node () { ACE_TRACE ("ACE_RB_Tree_Node<EXT_ID, INT_ID>::~ACE_RB_Tree_Node"); } @@ -906,7 +906,7 @@ dump_node_i (ACE_RB_Tree_Node<EXT_ID, INT_ID> &node) const /// Tests the red-black invariant(s) throughout the whole tree. template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> int -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::test_invariant (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::test_invariant () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::test_invariant"); ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1); @@ -1167,7 +1167,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::~ACE_RB_Tree_ template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> void -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump_i (void) const +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump_i () const { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump_i"); diff --git a/ACE/ace/RB_Tree.h b/ACE/ace/RB_Tree.h index b3b08f19aab..4c7b773ef27 100644 --- a/ACE/ace/RB_Tree.h +++ b/ACE/ace/RB_Tree.h @@ -56,34 +56,34 @@ public: ACE_RB_Tree_Node (const EXT_ID &k, const INT_ID &t); /// Destructor. - ~ACE_RB_Tree_Node (void); + ~ACE_RB_Tree_Node (); /// Key accessor. - EXT_ID &key (void); + EXT_ID &key (); /// Item accessor. - INT_ID &item (void); + INT_ID &item (); /// Set color of the node. void color (RB_Tree_Node_Color c); /// Get color of the node. - RB_Tree_Node_Color color (void); + RB_Tree_Node_Color color (); /// Accessor for node's parent pointer. - ACE_RB_Tree_Node<EXT_ID, INT_ID> *parent (void); + ACE_RB_Tree_Node<EXT_ID, INT_ID> *parent (); /// Mutator for node's parent pointer. void parent (ACE_RB_Tree_Node<EXT_ID, INT_ID> * p); /// Accessor for node's left child pointer. - ACE_RB_Tree_Node<EXT_ID, INT_ID> *left (void); + ACE_RB_Tree_Node<EXT_ID, INT_ID> *left (); /// Mutator for node's left child pointer. void left (ACE_RB_Tree_Node<EXT_ID, INT_ID> *l); /// Accessor for node's right child pointer. - ACE_RB_Tree_Node<EXT_ID, INT_ID> *right (void); + ACE_RB_Tree_Node<EXT_ID, INT_ID> *right (); /// Mutator for node's right child pointer void right (ACE_RB_Tree_Node<EXT_ID, INT_ID> * r); @@ -125,7 +125,7 @@ public: * of this method occurred. Placing the definition inline in * the header avoids such errors. */ - ACE_Allocator * allocator (void) const { return this->allocator_; } + ACE_Allocator * allocator () const { return this->allocator_; } protected: // = Protected members. @@ -210,10 +210,10 @@ public: /// Close down an RB_Tree and release dynamically allocated /// resources. - int close (void); + int close (); /// Destructor. - virtual ~ACE_RB_Tree (void); + virtual ~ACE_RB_Tree (); // = insertion, removal, and search methods. @@ -352,7 +352,7 @@ public: // = Public helper methods. /// Returns the current number of nodes in the tree. - size_t current_size (void) const; + size_t current_size () const; /// Assignment operator. void operator= (const ACE_RB_Tree<EXT_ID, @@ -368,31 +368,31 @@ public: * guard the state of an iterator. * @note The right name would be <lock>, but HP/C++ will choke on that! */ - ACE_LOCK &mutex (void); + ACE_LOCK &mutex (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iterator factory functions. /// Return forward iterator positioned at first node in tree. - ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> begin (void); + ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> begin (); /// Return forward iterator positioned at last node in tree. - ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> end (void); + ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> end (); /// Return reverse iterator positioned at last node in tree. - ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> rbegin (void); + ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> rbegin (); /// Return reverse iterator positioned at first node in tree. - ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> rend (void); + ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> rend (); /// Recursively tests the invariant red-black properties at each /// node of the tree. Returns 0 if invariant holds, else -1. /// This method is computationally expensive, and should only be /// called for testing purposes, and not in code that depends on the /// algorithmic complexity bounds provided by the other methods. - int test_invariant (void); + int test_invariant (); // = DEPRECATED methods. // Please migrate your code to use the new methods instead @@ -431,7 +431,7 @@ public: /// @deprecated /// Destroys all nodes and sets the root pointer null. - void clear (void); + void clear (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -504,7 +504,7 @@ protected: /// Close down an RB_Tree. this method should /// only be called with locks already held. - int close_i (void); + int close_i (); /** * Retrieves a pointer to the item corresponding to the @@ -599,18 +599,18 @@ public: // = Iteration methods. /// Returns 1 when the iteration has completed, otherwise 0. - int done (void) const; + int done () const; /// STL-like iterator dereference operator: returns a reference /// to the node underneath the iterator. - ACE_RB_Tree_Node<EXT_ID, INT_ID> & operator* (void) const; + ACE_RB_Tree_Node<EXT_ID, INT_ID> & operator* () const; /// STL-like iterator dereference operator: returns a pointer /// to the node underneath the iterator. - ACE_RB_Tree_Node<EXT_ID, INT_ID> * operator-> (void) const; + ACE_RB_Tree_Node<EXT_ID, INT_ID> * operator-> () const; /// Returns a const reference to the tree over which we're iterating. - const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &tree (void); + const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &tree (); /// Comparison operator: returns 1 if both iterators point to the same position, otherwise 0. bool operator== (const ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &) const; @@ -624,7 +624,7 @@ public: protected: /// Create the singular iterator. No valid iterator can be equal to /// it, it is illegal to dereference a singular iterator, etc. etc. - ACE_RB_Tree_Iterator_Base (void); + ACE_RB_Tree_Iterator_Base (); /** * Constructor. Takes an ACE_RB_Tree over which to iterate, and @@ -650,20 +650,20 @@ protected: ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS,ACE_LOCK> &tree); /// Destructor. - ~ACE_RB_Tree_Iterator_Base (void); + ~ACE_RB_Tree_Iterator_Base (); // = Internal methods /// Move forward by one element in the tree. Returns 0 when /// there are no more elements in the tree, otherwise 1. - int forward_i (void); + int forward_i (); /// Move back by one element in the tree. Returns 0 when /// there are no more elements in the tree, otherwise 1. - int reverse_i (void); + int reverse_i (); /// Dump the state of an object. - void dump_i (void) const; + void dump_i () const; // = Protected members. @@ -689,7 +689,7 @@ public: * It is illegal to deference the iterator, no valid iterator is * equal to a singular iterator, etc. etc. */ - ACE_RB_Tree_Iterator (void); + ACE_RB_Tree_Iterator (); /** * Constructor. Takes an ACE_RB_Tree over which to iterate, and @@ -714,27 +714,27 @@ public: ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &tree); /// Destructor. - ~ACE_RB_Tree_Iterator (void); + ~ACE_RB_Tree_Iterator (); // = ACE-style iteration methods. /// Move forward by one element in the tree. Returns /// 0 when all elements have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL-style iteration methods. /// Prefix advance. - ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator++ (void); + ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator++ (); /// Postfix advance. ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator-- (void); + ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator-- (); /// Postfix reverse. ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator-- (int); @@ -759,34 +759,34 @@ public: /// @deprecated /// Accessor for key of node under iterator (if any). - EXT_ID *key (void); + EXT_ID *key (); /// @deprecated /// Accessor for item of node under iterator (if any). - INT_ID *item (void); + INT_ID *item (); /// @deprecated /// Move to the first item in the iteration (and in the tree). - int first (void); + int first (); /// @deprecated /// Move to the last item in the iteration (and in the tree). - int last (void); + int last (); /// @deprecated /// Move to the next item in the iteration (and in the tree). - int next (void); + int next (); /// @deprecated /// Move to the previous item in the iteration (and in the tree). - int previous (void); + int previous (); /** * @deprecated: use the base class <done> method instead. * Returns 0 if the iterator is positioned over a valid ACE_RB_Tree * node, returns 1 if not. */ - int is_done (void); + int is_done (); }; @@ -804,7 +804,7 @@ public: * It is illegal to deference the iterator, no valid iterator is * equal to a singular iterator, etc. etc. */ - ACE_RB_Tree_Reverse_Iterator (void); + ACE_RB_Tree_Reverse_Iterator (); /** * Constructor. Takes an ACE_RB_Tree over which to iterate, and @@ -830,27 +830,27 @@ public: ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &tree); /// Destructor. - ~ACE_RB_Tree_Reverse_Iterator (void); + ~ACE_RB_Tree_Reverse_Iterator (); // = ACE-style iteration methods. /// Move forward by one element in the tree. Returns /// 0 when all elements have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL-style iteration methods. /// Prefix advance. - ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator++ (void); + ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator++ (); /// Postfix advance. ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator++ (int); /// Prefix reverse. - ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator-- (void); + ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & operator-- (); /// Postfix reverse. ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator-- (int); diff --git a/ACE/ace/RB_Tree.inl b/ACE/ace/RB_Tree.inl index dcebea5e71a..4e31894eb4d 100644 --- a/ACE/ace/RB_Tree.inl +++ b/ACE/ace/RB_Tree.inl @@ -154,7 +154,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::open (ACE_Allocator *alloc) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::close (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::close () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::close"); ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1); @@ -550,7 +550,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::unbind (ACE_RB_Tree_Node<EX template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_LOCK & -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::mutex (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::mutex () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::mutex"); return this->lock_; @@ -561,7 +561,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::mutex (void) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -580,7 +580,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void) const template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::begin (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::begin () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::begin"); @@ -592,7 +592,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::begin (void) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::end (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::end () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::end"); @@ -604,7 +604,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::end (void) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rbegin (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rbegin () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rbegin"); @@ -616,7 +616,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rbegin (void) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> -ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rend (void) +ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rend () { ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::rend"); @@ -719,7 +719,7 @@ ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::current_size () const template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator_Base (void) +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator_Base () : tree_ (0), node_ (0) { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator_Base (void)"); @@ -729,7 +729,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_I template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::done (void) const +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::done () const { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::done"); @@ -742,7 +742,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::done (void) c template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Node<EXT_ID, INT_ID> & -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator* (void) const +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator* () const { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator*"); return *(this->node_); @@ -754,7 +754,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator* (vo template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Node<EXT_ID, INT_ID> * -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-> (void) const +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-> () const { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator->"); return this->node_; @@ -764,7 +764,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-> (v // Returns a reference to the tree over which we're iterating. template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK>ACE_INLINE const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::tree (void) +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::tree () { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::tree"); return *tree_; @@ -800,7 +800,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator!= template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::forward_i (void) +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::forward_i () { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::forward_i"); @@ -818,7 +818,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::forward_i (vo template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::reverse_i (void) +ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::reverse_i () { ACE_TRACE ("ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::reverse_i"); @@ -838,7 +838,7 @@ ACE_RB_Tree_Iterator_Base<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::reverse_i (vo template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE -ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator (void) +ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator () : ACE_RB_Tree_Iterator_Base<EXT_ID,INT_ID,COMPARE_KEYS,ACE_LOCK> () { ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterator (void)"); @@ -849,7 +849,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Iterat template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance"); @@ -861,7 +861,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance (void) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -875,7 +875,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void) const template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & -ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator++ (void)"); @@ -902,7 +902,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ (int) template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & -ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator-- (void)"); @@ -1043,7 +1043,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::is_done () template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE -ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Reverse_Iterator (void) +ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Reverse_Iterator () : ACE_RB_Tree_Iterator_Base<EXT_ID,INT_ID,COMPARE_KEYS,ACE_LOCK> () { ACE_TRACE ("ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree_Reverse_Iterator (void)"); @@ -1054,7 +1054,7 @@ ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tre template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE int -ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance (void) +ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance () { ACE_TRACE ("ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance"); @@ -1066,7 +1066,7 @@ ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::advance (v template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE void -ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void) const +ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump"); @@ -1080,7 +1080,7 @@ ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::dump (void template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & -ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ (void) +ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ () { ACE_TRACE ("ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ (void)"); @@ -1107,7 +1107,7 @@ ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> ACE_INLINE ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> & -ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- (void) +ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- () { ACE_TRACE ("ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- (void)"); 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; diff --git a/ACE/ace/RW_Mutex.inl b/ACE/ace/RW_Mutex.inl index 3939b8c23fd..6d3566bb8d9 100644 --- a/ACE/ace/RW_Mutex.inl +++ b/ACE/ace/RW_Mutex.inl @@ -2,14 +2,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const ACE_rwlock_t & -ACE_RW_Mutex::lock (void) const +ACE_RW_Mutex::lock () const { // ACE_TRACE ("ACE_RW_Mutex::lock"); return this->lock_; } ACE_INLINE int -ACE_RW_Mutex::remove (void) +ACE_RW_Mutex::remove () { // ACE_TRACE ("ACE_RW_Mutex::remove"); int result = 0; @@ -22,56 +22,56 @@ ACE_RW_Mutex::remove (void) } ACE_INLINE int -ACE_RW_Mutex::acquire_read (void) +ACE_RW_Mutex::acquire_read () { // ACE_TRACE ("ACE_RW_Mutex::acquire_read"); return ACE_OS::rw_rdlock (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::acquire_write (void) +ACE_RW_Mutex::acquire_write () { // ACE_TRACE ("ACE_RW_Mutex::acquire_write"); return ACE_OS::rw_wrlock (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::acquire (void) +ACE_RW_Mutex::acquire () { // ACE_TRACE ("ACE_RW_Mutex::acquire"); return ACE_OS::rw_wrlock (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::tryacquire_read (void) +ACE_RW_Mutex::tryacquire_read () { // ACE_TRACE ("ACE_RW_Mutex::tryacquire_read"); return ACE_OS::rw_tryrdlock (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::tryacquire_write (void) +ACE_RW_Mutex::tryacquire_write () { // ACE_TRACE ("ACE_RW_Mutex::tryacquire_write"); return ACE_OS::rw_trywrlock (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::tryacquire_write_upgrade (void) +ACE_RW_Mutex::tryacquire_write_upgrade () { // ACE_TRACE ("ACE_RW_Mutex::tryacquire_write_upgrade"); return ACE_OS::rw_trywrlock_upgrade (&this->lock_); } ACE_INLINE int -ACE_RW_Mutex::tryacquire (void) +ACE_RW_Mutex::tryacquire () { // ACE_TRACE ("ACE_RW_Mutex::tryacquire"); return this->tryacquire_write (); } ACE_INLINE int -ACE_RW_Mutex::release (void) +ACE_RW_Mutex::release () { // ACE_TRACE ("ACE_RW_Mutex::release"); return ACE_OS::rw_unlock (&this->lock_); diff --git a/ACE/ace/RW_Thread_Mutex.h b/ACE/ace/RW_Thread_Mutex.h index d54997e7b03..54a4ebcfaa5 100644 --- a/ACE/ace/RW_Thread_Mutex.h +++ b/ACE/ace/RW_Thread_Mutex.h @@ -41,7 +41,7 @@ public: void *arg = 0); /// Default dtor. - ~ACE_RW_Thread_Mutex (void); + ~ACE_RW_Thread_Mutex (); /** * Conditionally upgrade a read lock to a write lock. This only @@ -51,10 +51,10 @@ 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 (); /// 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/RW_Thread_Mutex.inl b/ACE/ace/RW_Thread_Mutex.inl index a69c8b597c0..0531f9063d2 100644 --- a/ACE/ace/RW_Thread_Mutex.inl +++ b/ACE/ace/RW_Thread_Mutex.inl @@ -2,14 +2,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int -ACE_RW_Thread_Mutex::tryacquire_write_upgrade (void) +ACE_RW_Thread_Mutex::tryacquire_write_upgrade () { // ACE_TRACE ("ACE_RW_Thread_Mutex::tryacquire_write_upgrade"); return ACE_OS::rw_trywrlock_upgrade (&this->lock_); } ACE_INLINE -ACE_RW_Thread_Mutex::~ACE_RW_Thread_Mutex (void) +ACE_RW_Thread_Mutex::~ACE_RW_Thread_Mutex () { } diff --git a/ACE/ace/Recursive_Thread_Mutex.h b/ACE/ace/Recursive_Thread_Mutex.h index 8c4c867ff12..f88e7b79a1c 100644 --- a/ACE/ace/Recursive_Thread_Mutex.h +++ b/ACE/ace/Recursive_Thread_Mutex.h @@ -44,21 +44,21 @@ public: ACE_mutexattr_t *arg = 0); /// Implicitly release a recursive mutex. - ~ACE_Recursive_Thread_Mutex (void); + ~ACE_Recursive_Thread_Mutex (); /** * Implicitly release a recursive mutex. Note that only one thread * should call this method since it doesn't protect against race * conditions. */ - int remove (void); + int remove (); /** * Acquire a recursive mutex (will increment the nesting level and * not deadmutex if the owner of the mutex calls this method more * than once). */ - int acquire (void); + int acquire (); /** * Block the thread until we acquire the mutex or until @a tv times @@ -84,21 +84,21 @@ public: * Returns -1 on failure. If we "failed" because someone else * already had the lock, @c errno is set to @c EBUSY. */ - int tryacquire (void); + int tryacquire (); /** * Acquire mutex ownership. This calls acquire() and is only * here to make the ACE_Recusive_Thread_Mutex interface consistent * with the other synchronization APIs. */ - int acquire_read (void); + int acquire_read (); /** * Acquire mutex ownership. This calls acquire() and is only * here to make the ACE_Recusive_Thread_Mutex interface consistent * with the other synchronization APIs. */ - int acquire_write (void); + int acquire_write (); /** * Conditionally acquire mutex (i.e., won't block). This calls @@ -108,7 +108,7 @@ public: * because someone else already had the lock, @c errno is set to * @c EBUSY. */ - int tryacquire_read (void); + int tryacquire_read (); /** * Conditionally acquire mutex (i.e., won't block). This calls @@ -118,7 +118,7 @@ public: * because someone else already had the lock, @c errno is set to * @c EBUSY. */ - int tryacquire_write (void); + int tryacquire_write (); /** * This is only here to make the ACE_Recursive_Thread_Mutex @@ -126,17 +126,17 @@ public: * Assumes the caller has already acquired the mutex using one of * the above calls, and returns 0 (success) always. */ - int tryacquire_write_upgrade (void); + int tryacquire_write_upgrade (); /** * Releases a recursive mutex (will not release mutex until all the * nesting level drops to 0, which means the mutex is no longer * held). */ - int release (void); + int release (); /// Return the id of the thread that currently owns the mutex. - ACE_thread_t get_thread_id (void); + ACE_thread_t get_thread_id (); /** * Return the nesting level of the recursion. When a thread has @@ -146,16 +146,16 @@ public: * macro is enabled then this method may return -1 on platforms that * do not expose the internal count. */ - int get_nesting_level (void); + int get_nesting_level (); /// Returns a reference to the recursive mutex; - ACE_recursive_thread_mutex_t &lock (void); + ACE_recursive_thread_mutex_t &lock (); /// Returns a reference to the recursive mutex's internal mutex; - ACE_thread_mutex_t &get_nesting_mutex (void); + ACE_thread_mutex_t &get_nesting_mutex (); /// 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/Recursive_Thread_Mutex.inl b/ACE/ace/Recursive_Thread_Mutex.inl index 739e7756930..53fae98e083 100644 --- a/ACE/ace/Recursive_Thread_Mutex.inl +++ b/ACE/ace/Recursive_Thread_Mutex.inl @@ -2,13 +2,13 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_recursive_thread_mutex_t & -ACE_Recursive_Thread_Mutex::lock (void) +ACE_Recursive_Thread_Mutex::lock () { return lock_; } ACE_INLINE ACE_thread_mutex_t & -ACE_Recursive_Thread_Mutex::get_nesting_mutex (void) +ACE_Recursive_Thread_Mutex::get_nesting_mutex () { #if defined (ACE_HAS_RECURSIVE_MUTEXES) return static_cast<ACE_thread_mutex_t &> (lock_); @@ -29,19 +29,19 @@ ACE_Recursive_Thread_Mutex::set_thread_id (ACE_thread_t t) } ACE_INLINE int -ACE_Recursive_Thread_Mutex::acquire (void) +ACE_Recursive_Thread_Mutex::acquire () { return ACE_OS::recursive_mutex_lock (&this->lock_); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::release (void) +ACE_Recursive_Thread_Mutex::release () { return ACE_OS::recursive_mutex_unlock (&this->lock_); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::tryacquire (void) +ACE_Recursive_Thread_Mutex::tryacquire () { return ACE_OS::recursive_mutex_trylock (&this->lock_); } @@ -59,31 +59,31 @@ ACE_Recursive_Thread_Mutex::acquire (ACE_Time_Value *tv) } ACE_INLINE int -ACE_Recursive_Thread_Mutex::acquire_read (void) +ACE_Recursive_Thread_Mutex::acquire_read () { return this->acquire (); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::acquire_write (void) +ACE_Recursive_Thread_Mutex::acquire_write () { return this->acquire (); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::tryacquire_read (void) +ACE_Recursive_Thread_Mutex::tryacquire_read () { return this->tryacquire (); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::tryacquire_write (void) +ACE_Recursive_Thread_Mutex::tryacquire_write () { return this->tryacquire (); } ACE_INLINE int -ACE_Recursive_Thread_Mutex::tryacquire_write_upgrade (void) +ACE_Recursive_Thread_Mutex::tryacquire_write_upgrade () { return 0; } diff --git a/ACE/ace/Refcounted_Auto_Ptr.cpp b/ACE/ace/Refcounted_Auto_Ptr.cpp index d97c128b99a..ae40c485ad5 100644 --- a/ACE/ace/Refcounted_Auto_Ptr.cpp +++ b/ACE/ace/Refcounted_Auto_Ptr.cpp @@ -9,7 +9,7 @@ ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Refcounted_Auto_Ptr) ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Refcounted_Auto_Ptr_Rep) template <class X, class ACE_LOCK> -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr (void) +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr () { AUTO_REFCOUNTED_PTR_REP::detach (rep_); } diff --git a/ACE/ace/Refcounted_Auto_Ptr.h b/ACE/ace/Refcounted_Auto_Ptr.h index 670243dc1b5..b52872806ab 100644 --- a/ACE/ace/Refcounted_Auto_Ptr.h +++ b/ACE/ace/Refcounted_Auto_Ptr.h @@ -57,7 +57,7 @@ public: /// Destructor. Releases the reference to the underlying representation. /// If the release of that reference causes its reference count to reach 0, /// the representation object will also be destroyed. - virtual ~ACE_Refcounted_Auto_Ptr (void); + virtual ~ACE_Refcounted_Auto_Ptr (); /// Assignment operator that binds the current object and @a r to the same /// ACE_Refcounted_Auto_Ptr_Rep. An ACE_Refcounted_Auto_Ptr_Rep @@ -77,7 +77,7 @@ public: bool operator != (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const; /// Redirection operator - X *operator-> (void) const; + X *operator-> () const; /// Accessor method. X &operator *() const; @@ -90,20 +90,20 @@ public: /// Releases the reference to the underlying representation object. /// @retval The pointer value prior to releasing it. - X *release (void); + X *release (); /// Releases the current pointer value and then sets a new /// pointer value specified by @a p. void reset (X *p = 0); /// Get the pointer value. - X *get (void) const; + X *get () const; /// Get the reference count value. - long count (void) const; + long count () const; /// Returns @c true if this object does not contain a valid pointer. - bool null (void) const; + bool null () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -133,10 +133,10 @@ private: friend class ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>; /// Get the pointer value. - X *get (void) const; + X *get () const; /// Get the reference count value. - long count (void) const; + long count () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -174,7 +174,7 @@ private: private: // = Constructor and destructor private. ACE_Refcounted_Auto_Ptr_Rep (X *p = 0); - ~ACE_Refcounted_Auto_Ptr_Rep (void); + ~ACE_Refcounted_Auto_Ptr_Rep (); }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/Refcounted_Auto_Ptr.inl b/ACE/ace/Refcounted_Auto_Ptr.inl index f495076b153..2c46bbb5d3f 100644 --- a/ACE/ace/Refcounted_Auto_Ptr.inl +++ b/ACE/ace/Refcounted_Auto_Ptr.inl @@ -5,19 +5,19 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class X, class ACE_LOCK> inline long -ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::count (void) const +ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::count () const { return this->ref_count_.value(); } template <class X, class ACE_LOCK> inline long -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::count (void) const +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::count () const { return this->rep_->count (); } template <class X, class ACE_LOCK> inline bool -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::null (void) const +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::null () const { return (this->rep_ == 0 || this->rep_->get () == 0); } @@ -75,12 +75,12 @@ ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr_Rep (X *p) } template <class X, class ACE_LOCK> inline -ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr_Rep (void) +ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr_Rep () { } template <class X, class ACE_LOCK> inline X * -ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::get (void) const +ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::get () const { return this->ptr_.get (); } @@ -110,7 +110,7 @@ ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator!= (const ACE_Refcounted_Auto_Ptr< } template <class X, class ACE_LOCK> inline X * -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator-> (void) const +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator-> () const { return this->rep_->get(); } @@ -134,14 +134,14 @@ ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator bool () const } template <class X, class ACE_LOCK> inline X* -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::get (void) const +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::get () const { // We return the ACE_Future_rep. return this->rep_->get (); } template<class X, class ACE_LOCK> inline X * -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::release (void) +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::release () { X *p = this->get (); AUTO_REFCOUNTED_PTR_REP::detach (this->rep_); diff --git a/ACE/ace/Reverse_Lock_T.cpp b/ACE/ace/Reverse_Lock_T.cpp index e55e1f47261..eac8be2976b 100644 --- a/ACE/ace/Reverse_Lock_T.cpp +++ b/ACE/ace/Reverse_Lock_T.cpp @@ -14,34 +14,34 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class ACE_LOCKING_MECHANISM> -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::~ACE_Reverse_Lock (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::~ACE_Reverse_Lock () { } // Explicitly destroy the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::remove (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::remove () { return this->lock_.remove (); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire () { return this->lock_.release (); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire () { ACE_NOTSUP_RETURN (-1); } // Acquire the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::release (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::release () { if (this->acquire_method_ == ACE_Acquire_Method::ACE_READ) return this->lock_.acquire_read (); @@ -53,35 +53,35 @@ ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::release (void) // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_read (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_read () { ACE_NOTSUP_RETURN (-1); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_write (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_write () { ACE_NOTSUP_RETURN (-1); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_read (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_read () { ACE_NOTSUP_RETURN (-1); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write () { ACE_NOTSUP_RETURN (-1); } // Release the lock. template <class ACE_LOCKING_MECHANISM> int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade () { ACE_NOTSUP_RETURN (-1); } diff --git a/ACE/ace/Reverse_Lock_T.h b/ACE/ace/Reverse_Lock_T.h index f582c3f4986..571deb0de85 100644 --- a/ACE/ace/Reverse_Lock_T.h +++ b/ACE/ace/Reverse_Lock_T.h @@ -81,35 +81,35 @@ public: /// Destructor. If <lock_> was not passed in by the user, it will be /// deleted. - virtual ~ACE_Reverse_Lock (void); + virtual ~ACE_Reverse_Lock (); // = Lock accessors. /// Release the lock. - virtual int acquire (void); + virtual int acquire (); /// Release the lock. - virtual int tryacquire (void); + virtual int tryacquire (); /// Acquire the lock. - virtual int release (void); + virtual int release (); /// Release the lock. - virtual int acquire_read (void); + virtual int acquire_read (); /// Release the lock. - virtual int acquire_write (void); + virtual int acquire_write (); /// Release the lock. - virtual int tryacquire_read (void); + virtual int tryacquire_read (); /// Release the lock. - virtual int tryacquire_write (void); + virtual int tryacquire_write (); /// Release the lock. - virtual int tryacquire_write_upgrade (void); + virtual int tryacquire_write_upgrade (); /// Explicitly destroy the lock. - virtual int remove (void); + virtual int remove (); private: /// The concrete locking mechanism that all the methods delegate to. diff --git a/ACE/ace/SString.h b/ACE/ace/SString.h index 1f4f6749e83..2d599c6e54a 100644 --- a/ACE/ace/SString.h +++ b/ACE/ace/SString.h @@ -95,11 +95,11 @@ public: /// Transform into a copy of the ASCII character representation. /// (caller must delete) - char *char_rep (void) const; + char *char_rep () const; /// Transform into a copy of a USHORT16 representation (caller must /// delete). Note, behavior is undefined when sizeof (wchar_t) != 2. - ACE_UINT16 *ushort_rep (void) const; + ACE_UINT16 *ushort_rep () const; }; ACE_Export @@ -152,7 +152,7 @@ public: ACE_SString (char c, ACE_Allocator *alloc = 0); /// Default destructor. - ~ACE_SString (void); + ~ACE_SString (); /// Return the slot'th character in the string (doesn't perform /// bounds checking). @@ -176,23 +176,23 @@ public: ACE_SString substr (size_type offset, size_type length = npos) const; /// Returns a hash value for this string. - u_long hash (void) const; + u_long hash () const; /// Return the length of the string. - size_type length (void) const; + size_type length () const; /// Set the underlying pointer. Since this does not copy memory or /// delete existing memory use with extreme caution!!! void rep (char *s); /// Get the underlying pointer. - const char *rep (void) const; + const char *rep () const; /// Get the underlying pointer. - const char *fast_rep (void) const; + const char *fast_rep () const; /// Same as STL String's c_str() and fast_rep(). - const char *c_str (void) const; + const char *c_str () const; /// Comparison operator that will match substrings. Returns the /// slot of the first location that matches, else @c npos. @@ -230,7 +230,7 @@ public: int compare (const ACE_SString &s) const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -277,12 +277,12 @@ public: explicit ACE_Auto_String_Free (char* p = 0); ACE_Auto_String_Free (ACE_Auto_String_Free &rhs); ACE_Auto_String_Free& operator= (ACE_Auto_String_Free &rhs); - ~ACE_Auto_String_Free (void); + ~ACE_Auto_String_Free (); char* operator* () const; char operator[] (size_t i) const; - char* get (void) const; - char* release (void); + char* get () const; + char* release (); void reset (char* p = 0); private: diff --git a/ACE/ace/SString.inl b/ACE/ace/SString.inl index c5685c0905b..5079e51a174 100644 --- a/ACE/ace/SString.inl +++ b/ACE/ace/SString.inl @@ -60,7 +60,7 @@ operator+ (const ACE_NS_WString &s, const ACE_NS_WString &t) // ------------------------------------------------------- ACE_INLINE -ACE_SString::~ACE_SString (void) +ACE_SString::~ACE_SString () { } @@ -92,7 +92,7 @@ ACE_SString::operator[] (size_type slot) // Get the underlying pointer (does not make a copy, so beware!). ACE_INLINE const char * -ACE_SString::rep (void) const +ACE_SString::rep () const { ACE_TRACE ("ACE_SString::rep"); return this->rep_; @@ -101,7 +101,7 @@ ACE_SString::rep (void) const // Get the underlying pointer (does not make a copy, so beware!). ACE_INLINE const char * -ACE_SString::fast_rep (void) const +ACE_SString::fast_rep () const { ACE_TRACE ("ACE_SString::fast_rep"); return this->rep_; @@ -110,7 +110,7 @@ ACE_SString::fast_rep (void) const // Get the underlying pointer (does not make a copy, so beware!). ACE_INLINE const char * -ACE_SString::c_str (void) const +ACE_SString::c_str () const { ACE_TRACE ("ACE_SString::c_str"); return this->rep_; @@ -218,13 +218,13 @@ ACE_SString::rfind (char c, size_type pos) const } ACE_INLINE u_long -ACE_SString::hash (void) const +ACE_SString::hash () const { return ACE::hash_pjw (this->rep_); } ACE_INLINE ACE_SString::size_type -ACE_SString::length (void) const +ACE_SString::length () const { ACE_TRACE ("ACE_SString::length"); return this->len_; @@ -266,13 +266,13 @@ ACE_Auto_String_Free::operator= (ACE_Auto_String_Free& rhs) } ACE_INLINE -ACE_Auto_String_Free::~ACE_Auto_String_Free (void) +ACE_Auto_String_Free::~ACE_Auto_String_Free () { this->reset (0); } ACE_INLINE char* -ACE_Auto_String_Free::operator* (void) const +ACE_Auto_String_Free::operator* () const { return this->p_; } @@ -284,13 +284,13 @@ ACE_Auto_String_Free::operator[] (size_t i) const } ACE_INLINE char* -ACE_Auto_String_Free::get (void) const +ACE_Auto_String_Free::get () const { return this->p_; } ACE_INLINE char* -ACE_Auto_String_Free::release (void) +ACE_Auto_String_Free::release () { char* p = this->p_; this->p_ = 0; diff --git a/ACE/ace/Semaphore.h b/ACE/ace/Semaphore.h index a8fc282fa74..9b3c0dc1215 100644 --- a/ACE/ace/Semaphore.h +++ b/ACE/ace/Semaphore.h @@ -42,18 +42,18 @@ public: int max = 0x7fffffff); /// Implicitly destroy the semaphore. - ~ACE_Semaphore (void); + ~ACE_Semaphore (); /** * Explicitly destroy the semaphore. Note that only one thread * should call this method since it doesn't protect against race * conditions. */ - int remove (void); + int remove (); /// Block the thread until the semaphore count becomes /// greater than 0, then decrement it. - int acquire (void); + int acquire (); /** * Block the thread until the semaphore count becomes greater than 0 @@ -95,11 +95,11 @@ public: * because someone else already had the lock, @c errno is set to * @c EBUSY. */ - int tryacquire (void); + int tryacquire (); /// Increment the semaphore by 1, potentially unblocking a waiting /// thread. - int release (void); + int release (); /// Increment the semaphore by @a release_count, potentially /// unblocking waiting threads. @@ -110,14 +110,14 @@ public: * here to make the ACE_Semaphore interface consistent with the * other synchronization APIs. */ - int acquire_read (void); + int acquire_read (); /** * Acquire semaphore ownership. This calls <acquire> and is only * here to make the ACE_Semaphore interface consistent with the * other synchronization APIs. */ - int acquire_write (void); + int acquire_write (); /** * Conditionally acquire semaphore (i.e., won't block). This calls @@ -126,7 +126,7 @@ public: * 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 semaphore (i.e., won't block). This calls @@ -135,7 +135,7 @@ public: * Returns -1 on failure. If we "failed" because someone else * already had the lock, @c errno is set to @c EBUSY. */ - int tryacquire_write (void); + int tryacquire_write (); /** * This is only here to make the ACE_Semaphore @@ -143,16 +143,16 @@ public: * Assumes the caller has already acquired the semaphore using one of * the above calls, and returns 0 (success) always. */ - int tryacquire_write_upgrade (void); + int tryacquire_write_upgrade (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; /// Return the underlying lock. - const ACE_sema_t &lock (void) const; + const ACE_sema_t &lock () const; protected: ACE_sema_t semaphore_; diff --git a/ACE/ace/Semaphore.inl b/ACE/ace/Semaphore.inl index 8de0beef334..ba38cc96bd7 100644 --- a/ACE/ace/Semaphore.inl +++ b/ACE/ace/Semaphore.inl @@ -2,14 +2,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const ACE_sema_t & -ACE_Semaphore::lock (void) const +ACE_Semaphore::lock () const { // ACE_TRACE ("ACE_Semaphore::lock"); return this->semaphore_; } ACE_INLINE int -ACE_Semaphore::remove (void) +ACE_Semaphore::remove () { // ACE_TRACE ("ACE_Semaphore::remove"); int result = 0; @@ -22,7 +22,7 @@ ACE_Semaphore::remove (void) } ACE_INLINE int -ACE_Semaphore::acquire (void) +ACE_Semaphore::acquire () { // ACE_TRACE ("ACE_Semaphore::acquire"); return ACE_OS::sema_wait (&this->semaphore_); @@ -43,14 +43,14 @@ ACE_Semaphore::acquire (ACE_Time_Value *tv) } ACE_INLINE int -ACE_Semaphore::tryacquire (void) +ACE_Semaphore::tryacquire () { // ACE_TRACE ("ACE_Semaphore::tryacquire"); return ACE_OS::sema_trywait (&this->semaphore_); } ACE_INLINE int -ACE_Semaphore::release (void) +ACE_Semaphore::release () { // ACE_TRACE ("ACE_Semaphore::release"); return ACE_OS::sema_post (&this->semaphore_); @@ -68,7 +68,7 @@ ACE_Semaphore::release (unsigned int release_count) // other synchronization APIs. ACE_INLINE int -ACE_Semaphore::acquire_read (void) +ACE_Semaphore::acquire_read () { return this->acquire (); } @@ -78,7 +78,7 @@ ACE_Semaphore::acquire_read (void) // other synchronization APIs. ACE_INLINE int -ACE_Semaphore::acquire_write (void) +ACE_Semaphore::acquire_write () { return this->acquire (); } @@ -88,7 +88,7 @@ ACE_Semaphore::acquire_write (void) // interface consistent with the other synchronization APIs. ACE_INLINE int -ACE_Semaphore::tryacquire_read (void) +ACE_Semaphore::tryacquire_read () { return this->tryacquire (); } @@ -98,7 +98,7 @@ ACE_Semaphore::tryacquire_read (void) // interface consistent with the other synchronization APIs. ACE_INLINE int -ACE_Semaphore::tryacquire_write (void) +ACE_Semaphore::tryacquire_write () { return this->tryacquire (); } @@ -108,7 +108,7 @@ ACE_Semaphore::tryacquire_write (void) // already acquired the semaphore using one of the above calls, and // returns 0 (success) always. ACE_INLINE int -ACE_Semaphore::tryacquire_write_upgrade (void) +ACE_Semaphore::tryacquire_write_upgrade () { return 0; } diff --git a/ACE/ace/Service_Config.h b/ACE/ace/Service_Config.h index 3b27c1391d6..062fdd07daf 100644 --- a/ACE/ace/Service_Config.h +++ b/ACE/ace/Service_Config.h @@ -177,7 +177,7 @@ public: int active_; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -215,11 +215,11 @@ template<> class ACE_Export ACE_Threading_Helper<ACE_Thread_Mutex> { public: - ACE_Threading_Helper (void); - ~ACE_Threading_Helper (void); + ACE_Threading_Helper (); + ~ACE_Threading_Helper (); void set (void*); - void* get (void); + void* get (); private: /// Key for the thread-specific data, which is a simple pointer to @@ -234,11 +234,11 @@ template<> class ACE_Export ACE_Threading_Helper<ACE_Null_Mutex> { public: - ACE_Threading_Helper (void); - ~ACE_Threading_Helper (void); + ACE_Threading_Helper (); + ~ACE_Threading_Helper (); void set (void*); - void* get (void); + void* get (); }; #define ACE_Component_Config ACE_Service_Config @@ -308,7 +308,7 @@ public: /// Perform user-specified close activities and remove dynamic /// memory. - virtual ~ACE_Service_Config (void); + virtual ~ACE_Service_Config (); private: /** @@ -343,7 +343,7 @@ private: * Returns the process-wide global singleton instance. It would * have been created and will be managed by the Object Manager. */ - static ACE_Service_Config* singleton (void); + static ACE_Service_Config* singleton (); /** * Mutator for the currently active configuration context instance @@ -357,7 +357,7 @@ private: /** * Accessor for the "current" service gestalt */ - static ACE_Service_Gestalt* current (void); + static ACE_Service_Gestalt* current (); /** * This is what the static service initializators are hard-wired to @@ -370,7 +370,7 @@ private: * * @deprecated Use current() instead. */ - static ACE_Service_Gestalt* instance (void); + static ACE_Service_Gestalt* instance (); /** * Returns a process-wide global singleton instance in contrast with @@ -380,7 +380,7 @@ private: * for dynamically loading services. If you must, use with extreme * caution! */ - static ACE_Service_Gestalt* global (void); + static ACE_Service_Gestalt* global (); /** * Performs an open without parsing command-line arguments. The @@ -469,20 +469,20 @@ private: /// Tidy up and perform last rites when ACE_Service_Config is shut /// down. This method calls close_svcs(). Returns 0. - static int close (void); + static int close (); /// Perform user-specified close hooks and possibly delete all of the /// configured services in the <Service_Repository>. - static int fini_svcs (void); + static int fini_svcs (); /// True if reconfiguration occurred. - static int reconfig_occurred (void); + static int reconfig_occurred (); /// Indicate that reconfiguration occurred. static void reconfig_occurred (int); /// Perform the reconfiguration process. - static void reconfigure (void); + static void reconfigure (); // = The following methods are static in order to enforce Singleton // semantics for the Reactor, Service_Repository, Thread_Manager, @@ -504,7 +504,7 @@ private: /// idiom for registering static services: /// /// ACE_Service_Config::static_svcs ()->insert (...); - static ACE_Service_Gestalt* static_svcs (void); + static ACE_Service_Gestalt* static_svcs (); /// Insert a static service descriptor for processing on open_i(). The /// corresponding ACE_STATIC_SVC_* macros were changed to use this method @@ -553,7 +553,7 @@ private: #endif /* ACE_HAS_WINCE */ /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Set the signal_handler for internal use by ACE_Object_Manager only. static ACE_INLINE void signal_handler (ACE_Sig_Adapter *); @@ -589,7 +589,7 @@ private: * provided in the svc.conf file(s). Returns the number of errors * that occurred. */ - static int process_directives (void); + static int process_directives (); /// Handles signals to trigger reconfigurations. static void handle_signal (int sig, siginfo_t *, ucontext_t *); @@ -630,15 +630,15 @@ private: /// @deprecated /// Process service configuration requests that were provided on the /// command-line. Returns the number of errors that occurred. - static int process_commandline_directives (void); + static int process_commandline_directives (); /// Become a daemon. - static int start_daemon (void); + static int start_daemon (); // @deprecated // Add the default statically-linked services to the // ACE_Service_Repository. - static int load_static_svcs (void); + static int load_static_svcs (); protected: #if (ACE_USES_CLASSIC_SVC_CONF == 1) @@ -715,7 +715,7 @@ class ACE_Export ACE_Service_Config_Guard { public: ACE_Service_Config_Guard (ACE_Service_Gestalt* psg); - ~ACE_Service_Config_Guard (void); + ~ACE_Service_Config_Guard (); private: // Private AND not implemented to disable copying diff --git a/ACE/ace/Service_Config.inl b/ACE/ace/Service_Config.inl index 5cffe43449f..4f187015bcc 100644 --- a/ACE/ace/Service_Config.inl +++ b/ACE/ace/Service_Config.inl @@ -67,7 +67,7 @@ ACE_Service_Config::parse_args (int argc, ACE_TCHAR *argv[]) /// Return the global configuration instance. Allways returns the same /// instance ACE_INLINE ACE_Service_Gestalt * -ACE_Service_Config::global (void) +ACE_Service_Config::global () { return ACE_Service_Config::singleton()->instance_.get (); } @@ -78,7 +78,7 @@ ACE_Service_Config::global (void) /// ACE_Service_Config_Guard provides a way of temporarily replacing /// the "current" configuration instance in the context of a thread. ACE_INLINE ACE_Service_Gestalt * -ACE_Service_Config::instance (void) +ACE_Service_Config::instance () { return ACE_Service_Config::current (); } @@ -92,7 +92,7 @@ ACE_Service_Config::instance (void) // service registration problems. ACE_INLINE ACE_Service_Gestalt* -ACE_Service_Config::static_svcs (void) +ACE_Service_Config::static_svcs () { return ACE_Service_Config::current (); } @@ -154,7 +154,7 @@ ACE_Service_Config::process_directive (const ACE_TCHAR directive[]) /// Process service configuration requests as indicated in the queue of /// svc.conf files. ACE_INLINE int -ACE_Service_Config::process_directives (void) +ACE_Service_Config::process_directives () { return ACE_Service_Config::current ()->process_directives (false); } diff --git a/ACE/ace/Service_Gestalt.h b/ACE/ace/Service_Gestalt.h index 9946c460ec8..97af53c33ab 100644 --- a/ACE/ace/Service_Gestalt.h +++ b/ACE/ace/Service_Gestalt.h @@ -85,10 +85,10 @@ public: /// Perform user-specified close activities and remove dynamic /// memory. - ~ACE_Service_Gestalt (void); + ~ACE_Service_Gestalt (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /** * Performs an open without parsing command-line arguments. The @@ -185,7 +185,7 @@ public: /// Has it been opened? Returns the difference between the times /// open and close have been called on this instance - int is_opened (void); + int is_opened (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -253,7 +253,7 @@ public: /// Tidy up and perform last rites when ACE_Service_Config is shut /// down. This method calls @c close_svcs. Returns 0. - int close (void); + int close (); /// Registers a service descriptor for a static service object int insert (ACE_Static_Svc_Descriptor *stsd); @@ -318,14 +318,14 @@ public: struct Processed_Static_Svc { Processed_Static_Svc (const ACE_Static_Svc_Descriptor *); - ~Processed_Static_Svc (void); + ~Processed_Static_Svc (); ACE_TCHAR * name_; const ACE_Static_Svc_Descriptor *assd_; ACE_ALLOC_HOOK_DECLARE; }; /// Get the current ACE_Service_Repository held by this object. - ACE_Service_Repository* current_service_repository (void); + ACE_Service_Repository* current_service_repository (); protected: int parse_args_i (int, ACE_TCHAR *argv[], @@ -348,15 +348,15 @@ protected: bool ignore_debug_flag = false); /// Initialize the @c svc_conf_file_queue_ if necessary. - int init_svc_conf_file_queue (void); + int init_svc_conf_file_queue (); /// Add the default statically-linked services to the /// ACE_Service_Repository. - int load_static_svcs (void); + int load_static_svcs (); /// Process service configuration requests that were provided on the /// command-line. Returns the number of errors that occurred. - int process_commandline_directives (void); + int process_commandline_directives (); /// Process a static directive without also inserting its descriptor /// the global table. This avoids multiple additions when processing @@ -385,7 +385,7 @@ protected: /// Performs the common initialization tasks for a new or previously /// closed instance. Must not be virtual, as it is called from the /// constructor. - int init_i (void); + int init_i (); protected: /// Maintain a queue of services to be configured from the @@ -492,7 +492,7 @@ public: ACE_Service_Type_Dynamic_Guard (ACE_Service_Repository &r, ACE_TCHAR const *name); - ~ACE_Service_Type_Dynamic_Guard (void); + ~ACE_Service_Type_Dynamic_Guard (); private: ACE_Service_Repository & repo_; diff --git a/ACE/ace/Service_Gestalt.inl b/ACE/ace/Service_Gestalt.inl index ec46b27060a..3add95108d6 100644 --- a/ACE/ace/Service_Gestalt.inl +++ b/ACE/ace/Service_Gestalt.inl @@ -67,7 +67,7 @@ ACE_Service_Gestalt::find (const ACE_TCHAR name[], } ACE_INLINE ACE_Service_Repository* -ACE_Service_Gestalt::current_service_repository (void) +ACE_Service_Gestalt::current_service_repository () { return this->repo_; } diff --git a/ACE/ace/Service_Object.h b/ACE/ace/Service_Object.h index 0fdbc13b91c..4f123319c2e 100644 --- a/ACE/ace/Service_Object.h +++ b/ACE/ace/Service_Object.h @@ -48,13 +48,13 @@ public: ACE_Service_Object (ACE_Reactor * = 0); /// Destructor. - virtual ~ACE_Service_Object (void); + virtual ~ACE_Service_Object (); /// Temporarily disable a service without removing it completely. - virtual int suspend (void); + virtual int suspend (); /// Re-enable a previously suspended service. - virtual int resume (void); + virtual int resume (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -99,33 +99,33 @@ public: ACE_Service_Type_Impl *o, ACE_SHLIB_HANDLE handle, bool active); - ~ACE_Service_Type (void); + ~ACE_Service_Type (); - const ACE_TCHAR *name (void) const; + const ACE_TCHAR *name () const; void name (const ACE_TCHAR *); - const ACE_Service_Type_Impl *type (void) const; + const ACE_Service_Type_Impl *type () const; void type (const ACE_Service_Type_Impl *, bool active = true); /// Is this just a stub for the real thing? - bool is_forward_declaration (void) const; + bool is_forward_declaration () const; - int suspend (void) const; - int resume (void) const; - bool active (void) const; + int suspend () const; + int resume () const; + bool active () const; void active (bool turnon); /// Calls @c fini on @c type_ - int fini (void); + int fini (); /// Check if the service has been fini'ed. - bool fini_called (void) const; + bool fini_called () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Get to the DLL's implentation - const ACE_DLL & dll (void) const; + const ACE_DLL & dll () const; /// Sets the DLL void dll (const ACE_DLL&); @@ -170,7 +170,7 @@ public: ACE_Service_Object_Ptr (ACE_Service_Object *so); /// Release the held ACE_Service_Object by calling its fini() hook. - ~ACE_Service_Object_Ptr (void); + ~ACE_Service_Object_Ptr (); /// Smart pointer to access the underlying ACE_Service_Object. ACE_Service_Object *operator-> (); diff --git a/ACE/ace/Service_Object.inl b/ACE/ace/Service_Object.inl index e5c5099f061..e4a0a9f4f7a 100644 --- a/ACE/ace/Service_Object.inl +++ b/ACE/ace/Service_Object.inl @@ -6,7 +6,7 @@ ACE_INLINE ACE_Service_Object_Ptr::ACE_Service_Object_Ptr (ACE_Service_Object *s { } -ACE_INLINE ACE_Service_Object_Ptr::~ACE_Service_Object_Ptr (void) +ACE_INLINE ACE_Service_Object_Ptr::~ACE_Service_Object_Ptr () { this->service_object_->fini (); delete this->service_object_; @@ -19,14 +19,14 @@ ACE_Service_Object_Ptr::operator-> () } ACE_INLINE const ACE_TCHAR * -ACE_Service_Type::name (void) const +ACE_Service_Type::name () const { ACE_TRACE ("ACE_Service_Type::name"); return this->name_; } ACE_INLINE const ACE_Service_Type_Impl * -ACE_Service_Type::type (void) const +ACE_Service_Type::type () const { ACE_TRACE ("ACE_Service_Type::type"); return this->type_; @@ -41,7 +41,7 @@ ACE_Service_Type::type (const ACE_Service_Type_Impl *o, bool enabled) } ACE_INLINE bool -ACE_Service_Type::active (void) const +ACE_Service_Type::active () const { ACE_TRACE ("ACE_Service_Type::active"); return this->active_; @@ -55,7 +55,7 @@ ACE_Service_Type::active (bool turnon) } ACE_INLINE bool -ACE_Service_Type::fini_called (void) const +ACE_Service_Type::fini_called () const { ACE_TRACE ("ACE_Service_Type::fini_called"); return this->fini_already_called_; diff --git a/ACE/ace/Service_Repository.h b/ACE/ace/Service_Repository.h index 241e796d699..4ed680a955c 100644 --- a/ACE/ace/Service_Repository.h +++ b/ACE/ace/Service_Repository.h @@ -64,15 +64,15 @@ public: /// Close down the repository and free up dynamically allocated /// resources. - ~ACE_Service_Repository (void); + ~ACE_Service_Repository (); /// Close down the repository and free up dynamically allocated /// resources. - int close (void); + int close (); /// Finalize all the services by calling fini() and deleting /// dynamically allocated services. - int fini (void); + int fini (); /// Get pointer to a process-wide ACE_Service_Repository. static ACE_Service_Repository * instance @@ -83,7 +83,7 @@ public: static ACE_Service_Repository *instance (ACE_Service_Repository *); /// Delete the dynamically allocated Singleton. - static void close_singleton (void); + static void close_singleton (); // = Search structure operations (all acquire locks as necessary). @@ -126,13 +126,13 @@ public: int suspend (const ACE_TCHAR name[], const ACE_Service_Type **srp = 0); /// Return the current size of the repository. - size_t current_size (void) const; + size_t current_size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Returns a reference to the lock used by the ACE_Service_Repository - ACE_SYNCH_RECURSIVE_MUTEX &lock (void) const; + ACE_SYNCH_RECURSIVE_MUTEX &lock () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -224,7 +224,7 @@ public: bool ignored_suspended = true); /// Destructor. - ~ACE_Service_Repository_Iterator (void); + ~ACE_Service_Repository_Iterator (); public: @@ -235,20 +235,20 @@ public: int next (const ACE_Service_Type *&next_item); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Move forward by one element in the repository. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; private: - bool valid (void) const; + bool valid () const; private: ACE_Service_Repository_Iterator (const ACE_Service_Repository_Iterator&); diff --git a/ACE/ace/Service_Repository.inl b/ACE/ace/Service_Repository.inl index 9cbd388215e..09fcf738876 100644 --- a/ACE/ace/Service_Repository.inl +++ b/ACE/ace/Service_Repository.inl @@ -10,7 +10,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE size_t -ACE_Service_Repository::current_size (void) const +ACE_Service_Repository::current_size () const { ACE_TRACE ("ACE_Service_Repository::current_size"); ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, @@ -20,13 +20,13 @@ ACE_Service_Repository::current_size (void) const } ACE_INLINE ACE_SYNCH_RECURSIVE_MUTEX& -ACE_Service_Repository::lock (void) const +ACE_Service_Repository::lock () const { return this->lock_; } ACE_INLINE int -ACE_Service_Repository_Iterator::done (void) const +ACE_Service_Repository_Iterator::done () const { ACE_TRACE ("ACE_Service_Repository_Iterator::done"); @@ -34,7 +34,7 @@ ACE_Service_Repository_Iterator::done (void) const } ACE_INLINE -ACE_Service_Repository_Iterator::~ACE_Service_Repository_Iterator (void) +ACE_Service_Repository_Iterator::~ACE_Service_Repository_Iterator () { } diff --git a/ACE/ace/Shared_Object.h b/ACE/ace/Shared_Object.h index 6497f292e36..230bdad40da 100644 --- a/ACE/ace/Shared_Object.h +++ b/ACE/ace/Shared_Object.h @@ -33,16 +33,16 @@ class ACE_Export ACE_Shared_Object { public: /// Constructor - ACE_Shared_Object (void); + ACE_Shared_Object (); /// Destructor - virtual ~ACE_Shared_Object (void); + virtual ~ACE_Shared_Object (); /// Initializes object when dynamic linking occurs. virtual int init (int argc, ACE_TCHAR *argv[]); /// Terminates object when dynamic unlinking occurs. - virtual int fini (void); + virtual int fini (); /// Returns information on a service object. virtual int info (ACE_TCHAR **info_string, size_t length = 0) const; diff --git a/ACE/ace/Shared_Object.inl b/ACE/ace/Shared_Object.inl index 358a3fb7a4e..ec85cdfbce0 100644 --- a/ACE/ace/Shared_Object.inl +++ b/ACE/ace/Shared_Object.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Shared_Object::ACE_Shared_Object (void) +ACE_Shared_Object::ACE_Shared_Object () { } diff --git a/ACE/ace/Singleton.cpp b/ACE/ace/Singleton.cpp index 52ca2b53d36..758c647d10b 100644 --- a/ACE/ace/Singleton.cpp +++ b/ACE/ace/Singleton.cpp @@ -27,7 +27,7 @@ ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_DLL_Singleton_T) ACE_ALLOC_HOOK_DEFINE_Tc(ACE_DLL_Singleton_Adapter_T) template <class TYPE, class ACE_LOCK> void -ACE_Singleton<TYPE, ACE_LOCK>::dump (void) +ACE_Singleton<TYPE, ACE_LOCK>::dump () { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::dump"); @@ -41,7 +41,7 @@ ACE_Singleton<TYPE, ACE_LOCK>::dump (void) } template <class TYPE, class ACE_LOCK> ACE_Singleton<TYPE, ACE_LOCK> *& -ACE_Singleton<TYPE, ACE_LOCK>::instance_i (void) +ACE_Singleton<TYPE, ACE_LOCK>::instance_i () { #if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) // Pointer to the Singleton instance. This works around a bug with @@ -55,7 +55,7 @@ ACE_Singleton<TYPE, ACE_LOCK>::instance_i (void) } template <class TYPE, class ACE_LOCK> TYPE * -ACE_Singleton<TYPE, ACE_LOCK>::instance (void) +ACE_Singleton<TYPE, ACE_LOCK>::instance () { ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::instance"); @@ -133,7 +133,7 @@ ACE_Singleton<TYPE, ACE_LOCK>::cleanup (void *param) } template <class TYPE, class ACE_LOCK> void -ACE_Singleton<TYPE, ACE_LOCK>::close (void) +ACE_Singleton<TYPE, ACE_LOCK>::close () { ACE_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Singleton<TYPE, ACE_LOCK>::instance_i (); @@ -155,7 +155,7 @@ ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::singleton_ = 0; #endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */ template <class TYPE, class ACE_LOCK> void -ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump (void) +ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump () { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump"); @@ -170,7 +170,7 @@ ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump (void) template <class TYPE, class ACE_LOCK> ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *& -ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i (void) +ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i () { #if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) // Pointer to the Singleton instance. This works around a bug with @@ -184,7 +184,7 @@ ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i (void) } template <class TYPE, class ACE_LOCK> TYPE * -ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance (void) +ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance () { ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance"); @@ -237,7 +237,7 @@ ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance (void) } template <class TYPE, class ACE_LOCK> void -ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::close (void) +ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::close () { ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i (); @@ -250,7 +250,7 @@ ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::close (void) } template <class TYPE, class ACE_LOCK> void -ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump (void) +ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump () { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump"); @@ -264,7 +264,7 @@ ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump (void) } template <class TYPE, class ACE_LOCK> ACE_TSS_Singleton<TYPE, ACE_LOCK> *& -ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (void) +ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i () { #if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) // Pointer to the Singleton instance. This works around a bug with @@ -278,7 +278,7 @@ ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (void) } template <class TYPE, class ACE_LOCK> TYPE * -ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance (void) +ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance () { ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance"); @@ -343,7 +343,7 @@ ACE_TSS_Singleton<TYPE, ACE_LOCK>::cleanup (void *) } template <class TYPE, class ACE_LOCK> void -ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump (void) +ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump () { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump"); @@ -358,7 +358,7 @@ ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump (void) template <class TYPE, class ACE_LOCK> ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *& -ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (void) +ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i () { #if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) // Pointer to the Singleton instance. This works around a bug with @@ -372,7 +372,7 @@ ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (void) } template <class TYPE, class ACE_LOCK> TYPE * -ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance (void) +ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance () { ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance"); @@ -426,7 +426,7 @@ ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance (void) } template <class TYPE, class ACE_LOCK> void -ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::close (void) +ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::close () { ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&singleton = ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i (); @@ -454,7 +454,7 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::singleton_ = 0; #endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */ template <class TYPE, class ACE_LOCK> void -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump () { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump"); @@ -469,7 +469,7 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump (void) template <class TYPE, class ACE_LOCK> ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *& -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i () { ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i"); @@ -485,7 +485,7 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i (void) } template <class TYPE, class ACE_LOCK> TYPE * -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance () { ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance"); @@ -541,7 +541,7 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance (void) } template <class TYPE, class ACE_LOCK> void -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close () { ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close"); @@ -553,20 +553,20 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close (void) } template <class TYPE, class ACE_LOCK> void -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close_singleton (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close_singleton () { ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close_singleton"); ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close (); } template <class TYPE, class ACE_LOCK> const ACE_TCHAR * -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dll_name (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dll_name () { return this->instance ()->dll_name (); } template <class TYPE, class ACE_LOCK> const ACE_TCHAR * -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::name (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::name () { return this->instance ()->name (); } @@ -575,7 +575,7 @@ ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::name (void) /**********************************************************************/ template <class TYPE> const ACE_TCHAR* -ACE_DLL_Singleton_Adapter_T<TYPE>::dll_name (void) +ACE_DLL_Singleton_Adapter_T<TYPE>::dll_name () { // @todo make this a constant somewhere (or it there already is one // then use it. diff --git a/ACE/ace/Singleton.h b/ACE/ace/Singleton.h index d0cd95f4ae0..68932be0fb7 100644 --- a/ACE/ace/Singleton.h +++ b/ACE/ace/Singleton.h @@ -78,24 +78,24 @@ class ACE_Singleton : public ACE_Cleanup { public: /// Global access point to the Singleton. - static TYPE *instance (void); + static TYPE *instance (); /// Cleanup method, used by @c ace_cleanup_destroyer to destroy the /// ACE_Singleton. virtual void cleanup (void *param = 0); /// Explicitly delete the Singleton instance. - static void close (void); + static void close (); /// Dump the state of the object. - static void dump (void); + static void dump (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Default constructor. - ACE_Singleton (void); + ACE_Singleton (); /// Contained instance. TYPE instance_; @@ -106,7 +106,7 @@ protected: #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ /// Get pointer to the Singleton instance. - static ACE_Singleton<TYPE, ACE_LOCK> *&instance_i (void); + static ACE_Singleton<TYPE, ACE_LOCK> *&instance_i (); }; /** @@ -131,20 +131,20 @@ class ACE_Unmanaged_Singleton : public ACE_Singleton <TYPE, ACE_LOCK> { public: /// Global access point to the Singleton. - static TYPE *instance (void); + static TYPE *instance (); /// Explicitly delete the Singleton instance. - static void close (void); + static void close (); /// Dump the state of the object. - static void dump (void); + static void dump (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Default constructor. - ACE_Unmanaged_Singleton (void); + ACE_Unmanaged_Singleton (); #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) /// Pointer to the Singleton (ACE_Cleanup) instance. @@ -152,7 +152,7 @@ protected: #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ /// Get pointer to the Singleton instance. - static ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&instance_i (void); + static ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&instance_i (); }; /** @@ -178,21 +178,21 @@ class ACE_TSS_Singleton : public ACE_Cleanup { public: /// Global access point to the singleton. - static TYPE *instance (void); + static TYPE *instance (); /// Cleanup method, used by <ace_cleanup_destroyer> to destroy the /// singleton. virtual void cleanup (void *param = 0); /// Dump the state of the object. - static void dump (void); + static void dump (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Default constructor. - ACE_TSS_Singleton (void); + ACE_TSS_Singleton (); /// Contained instance. ACE_TSS_TYPE (TYPE) instance_; @@ -206,7 +206,7 @@ protected: #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ /// Get pointer to the TSS Singleton instance. - static ACE_TSS_Singleton<TYPE, ACE_LOCK> *&instance_i (void); + static ACE_TSS_Singleton<TYPE, ACE_LOCK> *&instance_i (); }; /** @@ -227,20 +227,20 @@ class ACE_Unmanaged_TSS_Singleton : public ACE_TSS_Singleton <TYPE, ACE_LOCK> { public: /// Global access point to the singleton. - static TYPE *instance (void); + static TYPE *instance (); /// Explicitly delete the singleton instance. - static void close (void); + static void close (); /// Dump the state of the object. - static void dump (void); + static void dump (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Default constructor. - ACE_Unmanaged_TSS_Singleton (void); + ACE_Unmanaged_TSS_Singleton (); #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) /// Pointer to the Singleton (ACE_Cleanup) instance. @@ -248,7 +248,7 @@ protected: #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ /// Get pointer to the Singleton instance. - static ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&instance_i (void); + static ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&instance_i (); }; /** @@ -282,29 +282,29 @@ public: //void cleanup (void *param = 0); /// Global access point to the Singleton. - static TYPE *instance (void); + static TYPE *instance (); /// Explicitly delete the Singleton instance. - static void close (void); + static void close (); - static void close_singleton (void); + static void close_singleton (); /// Dump the state of the object. - static void dump (void); + static void dump (); - const ACE_TCHAR *dll_name (void); + const ACE_TCHAR *dll_name (); - const ACE_TCHAR *name (void); + const ACE_TCHAR *name (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Default constructor. - ACE_DLL_Singleton_T (void); + ACE_DLL_Singleton_T (); /// Destructor. - ~ACE_DLL_Singleton_T (void); + ~ACE_DLL_Singleton_T (); /// Contained instance. TYPE instance_; @@ -315,14 +315,14 @@ protected: #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ /// Get pointer to the singleton instance. - static ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&instance_i (void); + static ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&instance_i (); }; template <class TYPE> class ACE_DLL_Singleton_Adapter_T : public TYPE { public: - const ACE_TCHAR *dll_name (void); + const ACE_TCHAR *dll_name (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; diff --git a/ACE/ace/Singleton.inl b/ACE/ace/Singleton.inl index 912271ba20f..479d38f7487 100644 --- a/ACE/ace/Singleton.inl +++ b/ACE/ace/Singleton.inl @@ -7,32 +7,32 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL // have a default constructor. Let the compiler figure it out . . . template <class TYPE, class ACE_LOCK> ACE_INLINE -ACE_Singleton<TYPE, ACE_LOCK>::ACE_Singleton (void) +ACE_Singleton<TYPE, ACE_LOCK>::ACE_Singleton () { } template <class TYPE, class ACE_LOCK> ACE_INLINE -ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::ACE_Unmanaged_Singleton (void) +ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::ACE_Unmanaged_Singleton () { } template <class TYPE, class ACE_LOCK> ACE_INLINE -ACE_TSS_Singleton<TYPE, ACE_LOCK>::ACE_TSS_Singleton (void) +ACE_TSS_Singleton<TYPE, ACE_LOCK>::ACE_TSS_Singleton () { } template <class TYPE, class ACE_LOCK> ACE_INLINE -ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::ACE_Unmanaged_TSS_Singleton (void) +ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::ACE_Unmanaged_TSS_Singleton () { } template <class TYPE, class ACE_LOCK> ACE_INLINE -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::ACE_DLL_Singleton_T (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::ACE_DLL_Singleton_T () { } template <class TYPE, class ACE_LOCK> -ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::~ACE_DLL_Singleton_T (void) +ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::~ACE_DLL_Singleton_T () { } diff --git a/ACE/ace/Static_Object_Lock.h b/ACE/ace/Static_Object_Lock.h index fc167062f6e..0539e0052e2 100644 --- a/ACE/ace/Static_Object_Lock.h +++ b/ACE/ace/Static_Object_Lock.h @@ -40,11 +40,11 @@ class ACE_Export ACE_Static_Object_Lock { public: /// Static lock access point. - static ACE_Recursive_Thread_Mutex *instance (void); + static ACE_Recursive_Thread_Mutex *instance (); /// For use only by ACE_Object_Manager to clean up lock if it /// what dynamically allocated. - static void cleanup_lock (void); + static void cleanup_lock (); }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/String_Base.cpp b/ACE/ace/String_Base.cpp index b12d8c4caaa..c98e0b760ab 100644 --- a/ACE/ace/String_Base.cpp +++ b/ACE/ace/String_Base.cpp @@ -113,7 +113,7 @@ ACE_String_Base<ACE_CHAR_T>::ACE_String_Base ( } template <class ACE_CHAR_T> -ACE_String_Base<ACE_CHAR_T>::~ACE_String_Base (void) +ACE_String_Base<ACE_CHAR_T>::~ACE_String_Base () { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::~ACE_String_Base"); @@ -250,7 +250,7 @@ ACE_String_Base<ACE_CHAR_T>::append (const ACE_CHAR_T* s, } template <class ACE_CHAR_T> u_long -ACE_String_Base<ACE_CHAR_T>::hash (void) const +ACE_String_Base<ACE_CHAR_T>::hash () const { return ACE::hash_pjw (reinterpret_cast<char *> ( @@ -345,7 +345,7 @@ ACE_String_Base<ACE_CHAR_T>::set (const ACE_CHAR_T *s, bool release) } template <class ACE_CHAR_T> void -ACE_String_Base<ACE_CHAR_T>::fast_clear (void) +ACE_String_Base<ACE_CHAR_T>::fast_clear () { this->len_ = 0; if (this->release_) @@ -365,7 +365,7 @@ ACE_String_Base<ACE_CHAR_T>::fast_clear (void) // Get a copy of the underlying representation. template <class ACE_CHAR_T> ACE_CHAR_T * -ACE_String_Base<ACE_CHAR_T>::rep (void) const +ACE_String_Base<ACE_CHAR_T>::rep () const { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::rep"); @@ -495,7 +495,7 @@ int ACE_String_Base_Iterator <ACE_CHAR_T>::next (ACE_CHAR_T * & ch) const } template <class ACE_CHAR_T> -int ACE_String_Base_Iterator <ACE_CHAR_T>::advance (void) +int ACE_String_Base_Iterator <ACE_CHAR_T>::advance () { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::advance"); @@ -545,7 +545,7 @@ int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::next (const ACE_CHAR_T * & ch) } template <class ACE_CHAR_T> -int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::advance (void) +int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::advance () { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::advance"); diff --git a/ACE/ace/String_Base.h b/ACE/ace/String_Base.h index 8005c34b768..b1915c8f2c0 100644 --- a/ACE/ace/String_Base.h +++ b/ACE/ace/String_Base.h @@ -164,7 +164,7 @@ public: /** * Deletes the memory... */ - ~ACE_String_Base (void); + ~ACE_String_Base (); /** * Return the <slot'th> character in the string (doesn't perform @@ -278,7 +278,7 @@ public: * and the next append() or +=() will cause a new buffer to be * allocated internally. */ - void fast_clear (void); + void fast_clear (); /** * Return a substring given an offset and length. @@ -344,14 +344,14 @@ public: * * @return Hash value of string */ - u_long hash (void) const; + u_long hash () const; /** * Return the length of the string. * * @return Length of stored string */ - size_type length (void) const; + size_type length () const; /** * Return the number of allocated CHARs in the string object. @@ -360,19 +360,19 @@ public: * @return Maximum number of ACE_CHAR_T units that can be stored, including * any terminating nul that may be needed. */ - size_t capacity (void) const; + size_t capacity () const; /** * Return @c true if the length of the string is zero, else @c false. */ - bool is_empty (void) const; + bool is_empty () const; /** * Return @c true if the length of the string is zero, else @c * false. We recommend using @c is_empty() instead since it's more * consistent with the ACE container naming conventions. */ - bool empty (void) const; + bool empty () const; /** * Get a copy of the underlying representation. @@ -384,7 +384,7 @@ public: * @return Pointer reference to the string data. Returned string is * zero terminated. */ - ACE_CHAR_T *rep (void) const; + ACE_CHAR_T *rep () const; /** * Get at the underlying representation directly! @@ -395,12 +395,12 @@ public: * that the string is zero terminated. * */ - const ACE_CHAR_T *fast_rep (void) const; + const ACE_CHAR_T *fast_rep () const; /** * Same as STL String's c_str() and fast_rep(). */ - const ACE_CHAR_T *c_str (void) const; + const ACE_CHAR_T *c_str () const; /** * Comparison operator that will match substrings. Returns the @@ -516,7 +516,7 @@ public: /** * Dump the state of an object. */ - void dump (void) const; + void dump () const; /** * This method is designed for high-performance. Please use with @@ -546,11 +546,11 @@ public: */ void swap (ACE_String_Base<ACE_CHAR_T> & str); - iterator begin (void); - const_iterator begin (void) const; + iterator begin (); + const_iterator begin () const; - iterator end (void); - const_iterator end (void) const; + iterator end (); + const_iterator end () const; /** * Declare the dynamic allocation hooks. @@ -627,7 +627,7 @@ public: ACE_String_Base_Iterator (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter); /// Destructor. - ~ACE_String_Base_Iterator (void); + ~ACE_String_Base_Iterator (); /** * Test if the iterator has seen all characters. @@ -635,7 +635,7 @@ public: * @retval 0 Characters still remain. * @retval 1 All characters have been seen. */ - int done (void) const; + int done () const; /** * Get the current character. @@ -652,7 +652,7 @@ public: * @retval 0 All characters have been seen. * @retval 1 Items still remain to be seen. */ - int advance (void); + int advance (); /** * Assignment operator @@ -667,12 +667,12 @@ public: * * @return Reference to current character seen by iterator. */ - ACE_CHAR_T & operator * (void); + ACE_CHAR_T & operator * (); /** * Prefix operator */ - ACE_String_Base_Iterator <ACE_CHAR_T> & operator ++ (void); + ACE_String_Base_Iterator <ACE_CHAR_T> & operator ++ (); /** * Postfix operator @@ -682,7 +682,7 @@ public: /** * Prefix operator */ - ACE_String_Base_Iterator <ACE_CHAR_T> & operator -- (void); + ACE_String_Base_Iterator <ACE_CHAR_T> & operator -- (); /** * Postfix operator @@ -754,7 +754,7 @@ public: ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & iter); /// Destructor. - ~ACE_String_Base_Const_Iterator (void); + ~ACE_String_Base_Const_Iterator (); /** * Test if the iterator has seen all characters. @@ -762,7 +762,7 @@ public: * @retval 0 Characters still remain. * @retval 1 All characters have been seen. */ - int done (void) const; + int done () const; /** * Get the current character. @@ -779,7 +779,7 @@ public: * @retval 0 All characters have been seen. * @retval 1 Items still remain to be seen. */ - int advance (void); + int advance (); /** * Assignment operator @@ -794,12 +794,12 @@ public: * * @return Reference to current character seen by iterator. */ - const ACE_CHAR_T & operator * (void); + const ACE_CHAR_T & operator * (); /** * Prefix operator */ - ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator ++ (void); + ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator ++ (); /** * Postfix operator @@ -809,7 +809,7 @@ public: /** * Prefix operator */ - ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator -- (void); + ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator -- (); /** * Postfix operator diff --git a/ACE/ace/String_Base.inl b/ACE/ace/String_Base.inl index 9e397d2d186..1ce4132a1e5 100644 --- a/ACE/ace/String_Base.inl +++ b/ACE/ace/String_Base.inl @@ -7,7 +7,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class ACE_CHAR_T> ACE_INLINE void -ACE_String_Base<ACE_CHAR_T>::dump (void) const +ACE_String_Base<ACE_CHAR_T>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::dump"); @@ -24,27 +24,27 @@ ACE_String_Base<ACE_CHAR_T>::assign_nocopy (const ACE_String_Base<ACE_CHAR_T> &s } template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type -ACE_String_Base<ACE_CHAR_T>::length (void) const +ACE_String_Base<ACE_CHAR_T>::length () const { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::length"); return this->len_; } template <class ACE_CHAR_T> ACE_INLINE size_t -ACE_String_Base<ACE_CHAR_T>::capacity (void) const +ACE_String_Base<ACE_CHAR_T>::capacity () const { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::capacity"); return this->buf_len_; } template <class ACE_CHAR_T> ACE_INLINE bool -ACE_String_Base<ACE_CHAR_T>::is_empty (void) const +ACE_String_Base<ACE_CHAR_T>::is_empty () const { return this->len_ == 0; } template <class ACE_CHAR_T> ACE_INLINE bool -ACE_String_Base<ACE_CHAR_T>::empty (void) const +ACE_String_Base<ACE_CHAR_T>::empty () const { return this->is_empty (); } @@ -79,13 +79,13 @@ ACE_String_Base<ACE_CHAR_T>::operator[] ( } template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T * -ACE_String_Base<ACE_CHAR_T>::fast_rep (void) const +ACE_String_Base<ACE_CHAR_T>::fast_rep () const { return this->rep_; } template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T * -ACE_String_Base<ACE_CHAR_T>::c_str (void) const +ACE_String_Base<ACE_CHAR_T>::c_str () const { return this->rep_; } @@ -140,28 +140,28 @@ ACE_String_Base<ACE_CHAR_T>::strstr (const ACE_String_Base<ACE_CHAR_T> &s) const } template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator -ACE_String_Base<ACE_CHAR_T>::begin (void) +ACE_String_Base<ACE_CHAR_T>::begin () { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin"); return iterator (*this); } template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator -ACE_String_Base<ACE_CHAR_T>::begin (void) const +ACE_String_Base<ACE_CHAR_T>::begin () const { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin"); return const_iterator (*this); } template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator -ACE_String_Base<ACE_CHAR_T>::end (void) +ACE_String_Base<ACE_CHAR_T>::end () { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end"); return iterator (*this, 1); } template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator -ACE_String_Base<ACE_CHAR_T>::end (void) const +ACE_String_Base<ACE_CHAR_T>::end () const { ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end"); return const_iterator (*this, 1); @@ -188,13 +188,13 @@ ACE_String_Base_Iterator (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter) } template <class ACE_CHAR_T> ACE_INLINE -ACE_String_Base_Iterator <ACE_CHAR_T>::~ACE_String_Base_Iterator (void) +ACE_String_Base_Iterator <ACE_CHAR_T>::~ACE_String_Base_Iterator () { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::~ACE_String_Base_Iterator"); } template <class ACE_CHAR_T> ACE_INLINE -int ACE_String_Base_Iterator <ACE_CHAR_T>::done (void) const +int ACE_String_Base_Iterator <ACE_CHAR_T>::done () const { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::done"); @@ -202,7 +202,7 @@ int ACE_String_Base_Iterator <ACE_CHAR_T>::done (void) const } template <class ACE_CHAR_T> ACE_INLINE -ACE_CHAR_T & ACE_String_Base_Iterator <ACE_CHAR_T>::operator * (void) +ACE_CHAR_T & ACE_String_Base_Iterator <ACE_CHAR_T>::operator * () { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator *"); @@ -211,7 +211,7 @@ ACE_CHAR_T & ACE_String_Base_Iterator <ACE_CHAR_T>::operator * (void) template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base_Iterator <ACE_CHAR_T> & -ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ (void) +ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ () { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator ++"); @@ -237,7 +237,7 @@ ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ (int) template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base_Iterator <ACE_CHAR_T> & -ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- (void) +ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- () { ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator --"); @@ -324,13 +324,13 @@ ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <ACE_CHAR_T } template <class ACE_CHAR_T> ACE_INLINE -ACE_String_Base_Const_Iterator <ACE_CHAR_T>::~ACE_String_Base_Const_Iterator (void) +ACE_String_Base_Const_Iterator <ACE_CHAR_T>::~ACE_String_Base_Const_Iterator () { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::~ACE_String_Base_Const_Iterator"); } template <class ACE_CHAR_T> ACE_INLINE -int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::done (void) const +int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::done () const { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::done"); @@ -338,7 +338,7 @@ int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::done (void) const } template <class ACE_CHAR_T> ACE_INLINE -const ACE_CHAR_T & ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator * (void) +const ACE_CHAR_T & ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator * () { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator *"); @@ -347,7 +347,7 @@ const ACE_CHAR_T & ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator * (void template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base_Const_Iterator <ACE_CHAR_T> & -ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ (void) +ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ () { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator ++"); @@ -373,7 +373,7 @@ ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ (int) template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base_Const_Iterator <ACE_CHAR_T> & -ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- (void) +ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- () { ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator --"); diff --git a/ACE/ace/TSS_Adapter.h b/ACE/ace/TSS_Adapter.h index 376f517924a..06abdac3803 100644 --- a/ACE/ace/TSS_Adapter.h +++ b/ACE/ace/TSS_Adapter.h @@ -41,7 +41,7 @@ public: ACE_TSS_Adapter (void *object, ACE_THR_DEST f); /// Perform the cleanup operation. - void cleanup (void); + void cleanup (); ACE_ALLOC_HOOK_DECLARE; diff --git a/ACE/ace/TSS_T.cpp b/ACE/ace/TSS_T.cpp index bee8257b0ad..9d3444c0793 100644 --- a/ACE/ace/TSS_T.cpp +++ b/ACE/ace/TSS_T.cpp @@ -34,7 +34,7 @@ extern "C" ACE_Export void ACE_TSS_C_cleanup (void *); #endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ template <class TYPE> -ACE_TSS<TYPE>::~ACE_TSS (void) +ACE_TSS<TYPE>::~ACE_TSS () { #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) if (this->once_) @@ -71,13 +71,13 @@ ACE_TSS<TYPE>::operator-> () const } template <class TYPE> -ACE_TSS<TYPE>::operator TYPE *(void) const +ACE_TSS<TYPE>::operator TYPE *() const { return this->ts_get (); } template <class TYPE> TYPE * -ACE_TSS<TYPE>::make_TSS_TYPE (void) const +ACE_TSS<TYPE>::make_TSS_TYPE () const { TYPE *temp = 0; ACE_NEW_RETURN (temp, @@ -87,7 +87,7 @@ ACE_TSS<TYPE>::make_TSS_TYPE (void) const } template <class TYPE> void -ACE_TSS<TYPE>::dump (void) const +ACE_TSS<TYPE>::dump () const { #if defined (ACE_HAS_DUMP) #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) @@ -110,7 +110,7 @@ ACE_TSS<TYPE>::cleanup (void *ptr) } template <class TYPE> int -ACE_TSS<TYPE>::ts_init (void) +ACE_TSS<TYPE>::ts_init () { // Ensure that we are serialized! ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->keylock_, 0); @@ -188,7 +188,7 @@ ACE_TSS<TYPE>::ACE_TSS (TYPE *ts_obj) } template <class TYPE> TYPE * -ACE_TSS<TYPE>::ts_get (void) const +ACE_TSS<TYPE>::ts_get () const { if (!this->once_) { @@ -269,7 +269,7 @@ ACE_TSS<TYPE>::ts_get (void) const // otherwise returns a pointer to the ts_obj. template <class TYPE> TYPE * -ACE_TSS<TYPE>::ts_object (void) const +ACE_TSS<TYPE>::ts_object () const { if (!this->once_) // Return 0 if we've never been initialized. return 0; @@ -342,7 +342,7 @@ ACE_TSS<TYPE>::ts_object (TYPE *new_ts_obj) ACE_ALLOC_HOOK_DEFINE_Tc(ACE_TSS_Guard) template <class ACE_LOCK> void -ACE_TSS_Guard<ACE_LOCK>::dump (void) const +ACE_TSS_Guard<ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); @@ -352,7 +352,7 @@ ACE_TSS_Guard<ACE_LOCK>::dump (void) const } template <class ACE_LOCK> void -ACE_TSS_Guard<ACE_LOCK>::init_key (void) +ACE_TSS_Guard<ACE_LOCK>::init_key () { this->key_ = ACE_OS::NULL_key; ACE_Thread::keycreate (&this->key_, @@ -365,13 +365,13 @@ ACE_TSS_Guard<ACE_LOCK>::init_key (void) } template <class ACE_LOCK> -ACE_TSS_Guard<ACE_LOCK>::ACE_TSS_Guard (void) +ACE_TSS_Guard<ACE_LOCK>::ACE_TSS_Guard () { this->init_key (); } template <class ACE_LOCK> int -ACE_TSS_Guard<ACE_LOCK>::release (void) +ACE_TSS_Guard<ACE_LOCK>::release () { Guard_Type *guard = 0; @@ -391,7 +391,7 @@ ACE_TSS_Guard<ACE_LOCK>::release (void) } template <class ACE_LOCK> int -ACE_TSS_Guard<ACE_LOCK>::remove (void) +ACE_TSS_Guard<ACE_LOCK>::remove () { Guard_Type *guard = 0; @@ -411,7 +411,7 @@ ACE_TSS_Guard<ACE_LOCK>::remove (void) } template <class ACE_LOCK> -ACE_TSS_Guard<ACE_LOCK>::~ACE_TSS_Guard (void) +ACE_TSS_Guard<ACE_LOCK>::~ACE_TSS_Guard () { Guard_Type *guard = 0; @@ -463,7 +463,7 @@ ACE_TSS_Guard<ACE_LOCK>::ACE_TSS_Guard (ACE_LOCK &lock, bool block) } template <class ACE_LOCK> int -ACE_TSS_Guard<ACE_LOCK>::acquire (void) +ACE_TSS_Guard<ACE_LOCK>::acquire () { Guard_Type *guard = 0; @@ -483,7 +483,7 @@ ACE_TSS_Guard<ACE_LOCK>::acquire (void) } template <class ACE_LOCK> int -ACE_TSS_Guard<ACE_LOCK>::tryacquire (void) +ACE_TSS_Guard<ACE_LOCK>::tryacquire () { Guard_Type *guard = 0; @@ -523,7 +523,7 @@ ACE_TSS_Write_Guard<ACE_LOCK>::ACE_TSS_Write_Guard (ACE_LOCK &lock, } template <class ACE_LOCK> int -ACE_TSS_Write_Guard<ACE_LOCK>::acquire (void) +ACE_TSS_Write_Guard<ACE_LOCK>::acquire () { Write_Guard_Type *guard = 0; @@ -543,7 +543,7 @@ ACE_TSS_Write_Guard<ACE_LOCK>::acquire (void) } template <class ACE_LOCK> int -ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire (void) +ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire () { Write_Guard_Type *guard = 0; @@ -563,19 +563,19 @@ ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire (void) } template <class ACE_LOCK> int -ACE_TSS_Write_Guard<ACE_LOCK>::acquire_write (void) +ACE_TSS_Write_Guard<ACE_LOCK>::acquire_write () { return this->acquire (); } template <class ACE_LOCK> int -ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire_write (void) +ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire_write () { return this->tryacquire (); } template <class ACE_LOCK> void -ACE_TSS_Write_Guard<ACE_LOCK>::dump (void) const +ACE_TSS_Write_Guard<ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TSS_Guard<ACE_LOCK>::dump (); @@ -603,7 +603,7 @@ ACE_TSS_Read_Guard<ACE_LOCK>::ACE_TSS_Read_Guard (ACE_LOCK &lock, bool block) } template <class ACE_LOCK> int -ACE_TSS_Read_Guard<ACE_LOCK>::acquire (void) +ACE_TSS_Read_Guard<ACE_LOCK>::acquire () { Read_Guard_Type *guard = 0; @@ -623,7 +623,7 @@ ACE_TSS_Read_Guard<ACE_LOCK>::acquire (void) } template <class ACE_LOCK> int -ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire (void) +ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire () { Read_Guard_Type *guard = 0; @@ -643,19 +643,19 @@ ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire (void) } template <class ACE_LOCK> int -ACE_TSS_Read_Guard<ACE_LOCK>::acquire_read (void) +ACE_TSS_Read_Guard<ACE_LOCK>::acquire_read () { return this->acquire (); } template <class ACE_LOCK> int -ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire_read (void) +ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire_read () { return this->tryacquire (); } template <class ACE_LOCK> void -ACE_TSS_Read_Guard<ACE_LOCK>::dump (void) const +ACE_TSS_Read_Guard<ACE_LOCK>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TSS_Guard<ACE_LOCK>::dump (); diff --git a/ACE/ace/TSS_T.h b/ACE/ace/TSS_T.h index d3097d54439..f894912f50b 100644 --- a/ACE/ace/TSS_T.h +++ b/ACE/ace/TSS_T.h @@ -94,7 +94,7 @@ public: /// Deregister this object from thread-specific storage administration. /// Will cause all threads' copies of TYPE to be destroyed. - virtual ~ACE_TSS (void); + virtual ~ACE_TSS (); /** * Set the thread-specific object for the calling thread. @@ -129,7 +129,7 @@ public: * may be 0 under odd error conditions; check errno for further * information. */ - TYPE *ts_object (void) const; + TYPE *ts_object () const; /** * Use a "smart pointer" to get the thread-specific data associated @@ -156,17 +156,17 @@ public: * may be 0 under odd error conditions; check errno for further * information. */ - operator TYPE *(void) const; + operator TYPE *() const; //@} /// Hook for construction parameters. - virtual TYPE *make_TSS_TYPE (void) const; + virtual TYPE *make_TSS_TYPE () const; // = Utility methods. /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -174,11 +174,11 @@ public: protected: /// Actually implements the code that retrieves the object from /// thread-specific storage. - TYPE *ts_get (void) const; + TYPE *ts_get () const; /// Factors out common code for initializing TSS. This must NOT be /// called with the lock held... - int ts_init (void); + int ts_init (); #if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) /// This implementation only works for non-threading systems... @@ -200,7 +200,7 @@ protected: # if defined (ACE_HAS_THR_C_DEST) ACE_TSS_Adapter *ts_value (void) const; # else - TYPE *ts_value (void) const; + TYPE *ts_value () const; # endif /* ACE_HAS_THR_C_DEST */ /// Stores a new plain value in the thread-specific storage. diff --git a/ACE/ace/TSS_T.inl b/ACE/ace/TSS_T.inl index 7e68976c88d..9d97fc374a4 100644 --- a/ACE/ace/TSS_T.inl +++ b/ACE/ace/TSS_T.inl @@ -53,7 +53,7 @@ ACE_TSS<TYPE>::ts_value (void) const } # else template <class TYPE> ACE_INLINE TYPE * -ACE_TSS<TYPE>::ts_value (void) const +ACE_TSS<TYPE>::ts_value () const { void *temp = 0; if (ACE_Thread::getspecific (this->key_, &temp) == -1) diff --git a/ACE/ace/Thread.h b/ACE/ace/Thread.h index 6290de52e9f..67a190dcc41 100644 --- a/ACE/ace/Thread.h +++ b/ACE/ace/Thread.h @@ -189,7 +189,7 @@ public: static int kill (ACE_thread_t, int signum); /// Yield the thread to another. - static void yield (void); + static void yield (); /** * Return the unique kernel handle of the thread. Note that on @@ -200,14 +200,14 @@ public: static void self (ACE_hthread_t &t_handle); /// Return the unique ID of the thread. - static ACE_thread_t self (void); + static ACE_thread_t self (); /// Exit the current thread and return "status". /// Should _not_ be called by main thread. static void exit (ACE_THR_FUNC_RETURN status = 0); /// Get the LWP concurrency level of the process. - static int getconcurrency (void); + static int getconcurrency (); /// Set the LWP concurrency level of the process. static int setconcurrency (int new_level); @@ -262,11 +262,11 @@ public: static int cancel (ACE_thread_t t_id); /// Test the cancel. - static void testcancel (void); + static void testcancel (); private: /// Ensure that we don't get instantiated. - ACE_Thread (void); + ACE_Thread (); }; ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/ACE/ace/Thread.inl b/ACE/ace/Thread.inl index 33f7fcf0b73..3313bdc53f9 100644 --- a/ACE/ace/Thread.inl +++ b/ACE/ace/Thread.inl @@ -50,7 +50,7 @@ ACE_Thread::getspecific (ACE_thread_key_t key, void **valuep) } ACE_INLINE ACE_thread_t -ACE_Thread::self (void) +ACE_Thread::self () { // ACE_TRACE ("ACE_Thread::self"); return ACE_OS::thr_self (); @@ -64,7 +64,7 @@ ACE_Thread::exit (ACE_THR_FUNC_RETURN status) } ACE_INLINE void -ACE_Thread::yield (void) +ACE_Thread::yield () { ACE_TRACE ("ACE_Thread::yield"); ACE_OS::thr_yield (); @@ -135,7 +135,7 @@ ACE_Thread::join (ACE_hthread_t wait_for, } ACE_INLINE int -ACE_Thread::getconcurrency (void) +ACE_Thread::getconcurrency () { ACE_TRACE ("ACE_Thread::getconcurrency"); return ACE_OS::thr_getconcurrency (); @@ -245,7 +245,7 @@ ACE_Thread::cancel (ACE_thread_t t_id) } ACE_INLINE void -ACE_Thread::testcancel (void) +ACE_Thread::testcancel () { ACE_TRACE ("ACE_Thread::testcancel"); diff --git a/ACE/ace/Thread_Adapter.h b/ACE/ace/Thread_Adapter.h index 660f120e646..a0e6fe6a5e4 100644 --- a/ACE/ace/Thread_Adapter.h +++ b/ACE/ace/Thread_Adapter.h @@ -62,21 +62,21 @@ public: * @c this, thereby rendering the object useless after the call * returns. */ - virtual ACE_THR_FUNC_RETURN invoke (void); + virtual ACE_THR_FUNC_RETURN invoke (); /// Accessor for the optional ACE_Thread_Manager. - ACE_Thread_Manager *thr_mgr (void); + ACE_Thread_Manager *thr_mgr (); ACE_ALLOC_HOOK_DECLARE; protected: /// Ensure that this object must be allocated on the heap. - ~ACE_Thread_Adapter (void); + ~ACE_Thread_Adapter (); private: /// Called by invoke, mainly here to separate the SEH stuff because /// SEH on Win32 doesn't compile with local vars with destructors. - virtual ACE_THR_FUNC_RETURN invoke_i (void); + virtual ACE_THR_FUNC_RETURN invoke_i (); private: /// Optional thread manager. diff --git a/ACE/ace/Thread_Adapter.inl b/ACE/ace/Thread_Adapter.inl index 06751eecd9a..cd584c6f672 100644 --- a/ACE/ace/Thread_Adapter.inl +++ b/ACE/ace/Thread_Adapter.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Thread_Manager * -ACE_Thread_Adapter::thr_mgr (void) +ACE_Thread_Adapter::thr_mgr () { return this->thr_mgr_; } diff --git a/ACE/ace/Thread_Control.h b/ACE/ace/Thread_Control.h index a392d83a5a5..d22a21166ff 100644 --- a/ACE/ace/Thread_Control.h +++ b/ACE/ace/Thread_Control.h @@ -47,7 +47,7 @@ public: /// Remove the thread from its associated Thread_Manager and exit /// the thread if <do_thr_exit> is enabled. - ~ACE_Thread_Control (void); + ~ACE_Thread_Control (); /// Remove this thread from its associated ACE_Thread_Manager and exit /// the thread if @a do_thr_exit is enabled. @@ -59,7 +59,7 @@ public: int insert (ACE_Thread_Manager *tm, bool insert = false); /// Returns the current Thread_Manager. - ACE_Thread_Manager *thr_mgr (void); + ACE_Thread_Manager *thr_mgr (); /// Atomically set a new Thread_Manager and return the old /// Thread_Manager. @@ -69,10 +69,10 @@ public: ACE_THR_FUNC_RETURN status (ACE_THR_FUNC_RETURN status); /// Get the current exit status. - ACE_THR_FUNC_RETURN status (void); + ACE_THR_FUNC_RETURN status (); /// 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/Thread_Control.inl b/ACE/ace/Thread_Control.inl index 20d03fe78e6..1122f7e35a3 100644 --- a/ACE/ace/Thread_Control.inl +++ b/ACE/ace/Thread_Control.inl @@ -15,7 +15,7 @@ ACE_Thread_Control::status (ACE_THR_FUNC_RETURN s) // Get the exit status. ACE_INLINE ACE_THR_FUNC_RETURN -ACE_Thread_Control::status (void) +ACE_Thread_Control::status () { ACE_OS_TRACE ("ACE_Thread_Control::status"); return this->status_; @@ -24,7 +24,7 @@ ACE_Thread_Control::status (void) // Returns the current <Thread_Manager>. ACE_INLINE ACE_Thread_Manager * -ACE_Thread_Control::thr_mgr (void) +ACE_Thread_Control::thr_mgr () { ACE_OS_TRACE ("ACE_Thread_Control::thr_mgr"); return this->tm_; diff --git a/ACE/ace/Thread_Exit.h b/ACE/ace/Thread_Exit.h index a6ac6516ccd..4f3882b9357 100644 --- a/ACE/ace/Thread_Exit.h +++ b/ACE/ace/Thread_Exit.h @@ -41,17 +41,17 @@ class ACE_Export ACE_Thread_Exit { public: /// Capture the Thread that will be cleaned up automatically. - ACE_Thread_Exit (void); + ACE_Thread_Exit (); /// Set the ACE_Thread_Manager. void thr_mgr (ACE_Thread_Manager *tm); /// Destructor calls the thread-specific exit hooks when a thread /// exits. - ~ACE_Thread_Exit (void); + ~ACE_Thread_Exit (); /// Singleton access point. - static ACE_Thread_Exit *instance (void); + static ACE_Thread_Exit *instance (); /// Cleanup method, used by the ACE_Object_Manager to destroy the /// singleton. @@ -90,13 +90,13 @@ public: ACE_Thread_Exit_Maybe (int flag = 0); /// Destroys the underlying ACE_Thread_Exit instance if it exists. - ~ACE_Thread_Exit_Maybe (void); + ~ACE_Thread_Exit_Maybe (); /// Delegates to underlying instance. - ACE_Thread_Exit * operator -> (void) const; + ACE_Thread_Exit * operator -> () const; /// Returns the underlying instance. - ACE_Thread_Exit * instance (void) const; + ACE_Thread_Exit * instance () const; private: 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<ACE_Thread_Descriptor>; friend class ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor>; 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<ACE_Thread_Descriptor>; friend class ACE_Double_Linked_List_Iterator<ACE_Thread_Descriptor>; 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. diff --git a/ACE/ace/Thread_Manager.inl b/ACE/ace/Thread_Manager.inl index e3ddda3a897..c6c93f270ee 100644 --- a/ACE/ace/Thread_Manager.inl +++ b/ACE/ace/Thread_Manager.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_At_Thread_Exit::ACE_At_Thread_Exit (void) +ACE_At_Thread_Exit::ACE_At_Thread_Exit () : next_ (0), td_ (0), was_applied_ (false), @@ -39,7 +39,7 @@ ACE_At_Thread_Exit::is_owner (bool owner) } ACE_INLINE void -ACE_At_Thread_Exit::do_apply (void) +ACE_At_Thread_Exit::do_apply () { if (!this->was_applied_ && this->is_owner_) td_->at_pop(); @@ -56,7 +56,7 @@ ACE_At_Thread_Exit_Func::ACE_At_Thread_Exit_Func (void *object, } ACE_INLINE -ACE_Thread_Descriptor_Base::ACE_Thread_Descriptor_Base (void) +ACE_Thread_Descriptor_Base::ACE_Thread_Descriptor_Base () : ACE_OS_Thread_Descriptor (), thr_id_ (ACE_OS::NULL_thread), thr_handle_ (ACE_OS::NULL_hthread), @@ -69,7 +69,7 @@ ACE_Thread_Descriptor_Base::ACE_Thread_Descriptor_Base (void) } ACE_INLINE -ACE_Thread_Descriptor_Base::~ACE_Thread_Descriptor_Base (void) +ACE_Thread_Descriptor_Base::~ACE_Thread_Descriptor_Base () { } @@ -89,7 +89,7 @@ ACE_Thread_Descriptor_Base::operator!=(const ACE_Thread_Descriptor_Base &rhs) co } ACE_INLINE ACE_Task_Base * -ACE_Thread_Descriptor_Base::task (void) const +ACE_Thread_Descriptor_Base::task () const { ACE_TRACE ("ACE_Thread_Descriptor_Base::task"); return this->task_; @@ -98,7 +98,7 @@ ACE_Thread_Descriptor_Base::task (void) const // Group ID. ACE_INLINE int -ACE_Thread_Descriptor_Base::grp_id (void) const +ACE_Thread_Descriptor_Base::grp_id () const { ACE_TRACE ("ACE_Thread_Descriptor_Base::grp_id"); return grp_id_; @@ -106,7 +106,7 @@ ACE_Thread_Descriptor_Base::grp_id (void) const // Current state of the thread. ACE_INLINE ACE_UINT32 -ACE_Thread_Descriptor_Base::state (void) const +ACE_Thread_Descriptor_Base::state () const { ACE_TRACE ("ACE_Thread_Descriptor_Base::state"); return thr_state_; @@ -114,7 +114,7 @@ ACE_Thread_Descriptor_Base::state (void) const // Reset this base descriptor. ACE_INLINE void -ACE_Thread_Descriptor_Base::reset (void) +ACE_Thread_Descriptor_Base::reset () { ACE_TRACE ("ACE_Thread_Descriptor_Base::reset"); this->thr_id_ = ACE_OS::NULL_thread; @@ -127,7 +127,7 @@ ACE_Thread_Descriptor_Base::reset (void) // Unique thread id. ACE_INLINE ACE_thread_t -ACE_Thread_Descriptor::self (void) const +ACE_Thread_Descriptor::self () const { ACE_TRACE ("ACE_Thread_Descriptor::self"); return this->thr_id_; @@ -159,7 +159,7 @@ ACE_Thread_Descriptor::set_next (ACE_Thread_Descriptor *td) // Get the <next_> pointer ACE_INLINE ACE_Thread_Descriptor * -ACE_Thread_Descriptor::get_next (void) const +ACE_Thread_Descriptor::get_next () const { ACE_TRACE ("ACE_Thread_Descriptor::get_next"); return static_cast<ACE_Thread_Descriptor * ACE_CAST_CONST> (this->next_); @@ -180,7 +180,7 @@ ACE_Thread_Descriptor::reset (ACE_Thread_Manager *tm) } ACE_INLINE ACE_Thread_Descriptor * -ACE_Thread_Manager::thread_desc_self (void) +ACE_Thread_Manager::thread_desc_self () { // This method must be called with lock held. @@ -210,14 +210,14 @@ ACE_Thread_Manager::thread_desc_self (void) // Return the unique ID of the thread. ACE_INLINE ACE_thread_t -ACE_Thread_Manager::thr_self (void) +ACE_Thread_Manager::thr_self () { ACE_TRACE ("ACE_Thread_Manager::thr_self"); return ACE_Thread::self (); } ACE_INLINE ACE_Task_Base * -ACE_Thread_Manager::task (void) +ACE_Thread_Manager::task () { ACE_TRACE ("ACE_Thread_Manager::task"); @@ -275,7 +275,7 @@ ACE_Thread_Manager::wait_on_exit (int do_wait) } ACE_INLINE int -ACE_Thread_Manager::wait_on_exit (void) +ACE_Thread_Manager::wait_on_exit () { return this->automatic_wait_; } @@ -294,7 +294,7 @@ ACE_Thread_Manager::register_as_terminated (ACE_Thread_Descriptor *td) } ACE_INLINE size_t -ACE_Thread_Manager::count_threads (void) const +ACE_Thread_Manager::count_threads () const { return this->thr_list_.size (); } diff --git a/ACE/ace/Thread_Mutex.h b/ACE/ace/Thread_Mutex.h index 9270aa68aeb..72e1e5e6e37 100644 --- a/ACE/ace/Thread_Mutex.h +++ b/ACE/ace/Thread_Mutex.h @@ -53,17 +53,17 @@ public: ACE_mutexattr_t *attributes = 0); /// Implicitly destroy the mutex. - ~ACE_Thread_Mutex (void); + ~ACE_Thread_Mutex (); /** * Explicitly destroy the mutex. Note that only one thread should * call this method since it doesn't protect against race * conditions. */ - int remove (void); + int remove (); /// Acquire lock ownership (wait on queue if necessary). - int acquire (void); + int acquire (); /** * Block the thread until we acquire the mutex or until @a tv times @@ -89,24 +89,24 @@ public: * -1 on failure. If we "failed" because someone else already had * the lock, @c errno is set to @c EBUSY. */ - int tryacquire (void); + int tryacquire (); /// Release lock and unblock a thread at head of queue. - int release (void); + int release (); /** * Acquire mutex ownership. This calls acquire() and is only here * to make the ACE_Thread_Mutex interface consistent with the * other synchronization APIs. */ - int acquire_read (void); + int acquire_read (); /** * Acquire mutex ownership. This calls acquire() and is only here * to make the ACE_Thread_Mutex interface consistent with the * other synchronization APIs. */ - int acquire_write (void); + int acquire_write (); /** * Conditionally acquire mutex (i.e., won't block). This calls @@ -115,7 +115,7 @@ public: * 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 mutex (i.e., won't block). This calls @@ -124,7 +124,7 @@ public: * Returns -1 on failure. If we "failed" because someone else * already had the lock, @c errno is set to @c EBUSY. */ - int tryacquire_write (void); + int tryacquire_write (); /** * This is only here to make the ACE_Thread_Mutex interface @@ -132,14 +132,14 @@ public: * caller has already acquired the mutex using one of the above * calls, and returns 0 (success) always. */ - int tryacquire_write_upgrade (void); + int tryacquire_write_upgrade (); /// Return the underlying mutex. - const ACE_thread_mutex_t &lock (void) const; - ACE_thread_mutex_t &lock (void); + const ACE_thread_mutex_t &lock () const; + ACE_thread_mutex_t &lock (); /// 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/Thread_Mutex.inl b/ACE/ace/Thread_Mutex.inl index e3d2719327e..e12b6829f49 100644 --- a/ACE/ace/Thread_Mutex.inl +++ b/ACE/ace/Thread_Mutex.inl @@ -2,56 +2,56 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const ACE_thread_mutex_t & -ACE_Thread_Mutex::lock (void) const +ACE_Thread_Mutex::lock () const { // ACE_TRACE ("ACE_Thread_Mutex::lock"); return this->lock_; } ACE_INLINE ACE_thread_mutex_t & -ACE_Thread_Mutex::lock (void) +ACE_Thread_Mutex::lock () { // ACE_TRACE ("ACE_Thread_Mutex::lock"); return this->lock_; } ACE_INLINE int -ACE_Thread_Mutex::acquire_read (void) +ACE_Thread_Mutex::acquire_read () { // ACE_TRACE ("ACE_Thread_Mutex::acquire_read"); return ACE_OS::thread_mutex_lock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::acquire_write (void) +ACE_Thread_Mutex::acquire_write () { // ACE_TRACE ("ACE_Thread_Mutex::acquire_write"); return ACE_OS::thread_mutex_lock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::tryacquire_read (void) +ACE_Thread_Mutex::tryacquire_read () { // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_read"); return ACE_OS::thread_mutex_trylock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::tryacquire_write (void) +ACE_Thread_Mutex::tryacquire_write () { // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write"); return ACE_OS::thread_mutex_trylock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::tryacquire_write_upgrade (void) +ACE_Thread_Mutex::tryacquire_write_upgrade () { // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write_upgrade"); return 0; } ACE_INLINE int -ACE_Thread_Mutex::acquire (void) +ACE_Thread_Mutex::acquire () { // ACE_TRACE ("ACE_Thread_Mutex::acquire"); return ACE_OS::thread_mutex_lock (&this->lock_); @@ -72,21 +72,21 @@ ACE_Thread_Mutex::acquire (ACE_Time_Value *tv) } ACE_INLINE int -ACE_Thread_Mutex::tryacquire (void) +ACE_Thread_Mutex::tryacquire () { // ACE_TRACE ("ACE_Thread_Mutex::tryacquire"); return ACE_OS::thread_mutex_trylock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::release (void) +ACE_Thread_Mutex::release () { // ACE_TRACE ("ACE_Thread_Mutex::release"); return ACE_OS::thread_mutex_unlock (&this->lock_); } ACE_INLINE int -ACE_Thread_Mutex::remove (void) +ACE_Thread_Mutex::remove () { // ACE_TRACE ("ACE_Thread_Mutex::remove"); int result = 0; diff --git a/ACE/ace/Thread_Semaphore.h b/ACE/ace/Thread_Semaphore.h index c59e25ba97c..f1d80beb55c 100644 --- a/ACE/ace/Thread_Semaphore.h +++ b/ACE/ace/Thread_Semaphore.h @@ -46,10 +46,10 @@ public: int max = 0x7FFFFFFF); /// Default destructor. - ~ACE_Thread_Semaphore (void); + ~ACE_Thread_Semaphore (); /// 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/Thread_Semaphore.inl b/ACE/ace/Thread_Semaphore.inl index 9a2a0affed3..d81a013d68d 100644 --- a/ACE/ace/Thread_Semaphore.inl +++ b/ACE/ace/Thread_Semaphore.inl @@ -2,7 +2,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE -ACE_Thread_Semaphore::~ACE_Thread_Semaphore (void) +ACE_Thread_Semaphore::~ACE_Thread_Semaphore () { } diff --git a/ACE/ace/Time_Policy.h b/ACE/ace/Time_Policy.h index 8302975be93..b50d0594a4d 100644 --- a/ACE/ace/Time_Policy.h +++ b/ACE/ace/Time_Policy.h @@ -35,7 +35,7 @@ public: ACE_Time_Value_T<ACE_System_Time_Policy> operator() () const; /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); + void set_gettimeofday (ACE_Time_Value (*gettimeofday)()); }; /** @@ -50,7 +50,7 @@ public: ACE_Time_Value_T<ACE_HR_Time_Policy> operator() () const; /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); + void set_gettimeofday (ACE_Time_Value (*gettimeofday)()); }; /** @@ -92,7 +92,7 @@ public: ACE_Time_Value_T<ACE_FPointer_Time_Policy> operator()() const; /// Satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); + void set_gettimeofday (ACE_Time_Value (*gettimeofday)()); private: FPtr function_; }; @@ -122,7 +122,7 @@ public: ACE_Delegating_Time_Policy &operator = (ACE_Delegating_Time_Policy&&) = default; /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); + void set_gettimeofday (ACE_Time_Value (*gettimeofday)()); private: ACE_Dynamic_Time_Policy_Base const * delegate_; }; @@ -142,7 +142,7 @@ public: ACE_Time_Value_T<ACE_Delegating_Time_Policy> operator()() const; /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); + void set_gettimeofday (ACE_Time_Value (*gettimeofday)()); protected: /// Return the current time according to policy implementation. virtual ACE_Time_Value_T<ACE_Delegating_Time_Policy> gettimeofday () const = 0; diff --git a/ACE/ace/Time_Policy.inl b/ACE/ace/Time_Policy.inl index 8ecea822490..f057ed3a0f7 100644 --- a/ACE/ace/Time_Policy.inl +++ b/ACE/ace/Time_Policy.inl @@ -11,7 +11,7 @@ ACE_System_Time_Policy::operator()() const } ACE_INLINE void -ACE_System_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) +ACE_System_Time_Policy::set_gettimeofday (ACE_Time_Value (*)()) { } @@ -22,7 +22,7 @@ ACE_HR_Time_Policy::operator()() const } ACE_INLINE void -ACE_HR_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) +ACE_HR_Time_Policy::set_gettimeofday (ACE_Time_Value (*)()) { } @@ -46,7 +46,7 @@ ACE_FPointer_Time_Policy::operator()() const } ACE_INLINE void -ACE_FPointer_Time_Policy::set_gettimeofday (ACE_Time_Value (*f)(void)) +ACE_FPointer_Time_Policy::set_gettimeofday (ACE_Time_Value (*f)()) { this->function_ = f; } @@ -58,7 +58,7 @@ ACE_Dynamic_Time_Policy_Base::operator()() const } ACE_INLINE void -ACE_Dynamic_Time_Policy_Base::set_gettimeofday (ACE_Time_Value (*)(void)) +ACE_Dynamic_Time_Policy_Base::set_gettimeofday (ACE_Time_Value (*)()) { } @@ -69,7 +69,7 @@ ACE_Delegating_Time_Policy::operator()() const } ACE_INLINE void -ACE_Delegating_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) +ACE_Delegating_Time_Policy::set_gettimeofday (ACE_Time_Value (*)()) { } diff --git a/ACE/ace/Time_Value.h b/ACE/ace/Time_Value.h index af6a6225387..c543896ca90 100644 --- a/ACE/ace/Time_Value.h +++ b/ACE/ace/Time_Value.h @@ -64,7 +64,7 @@ public: static const ACE_Time_Value max_time; /// Default Constructor. - ACE_Time_Value (void); + ACE_Time_Value (); /// Constructor. explicit ACE_Time_Value (time_t sec, suseconds_t usec = 0); @@ -140,7 +140,7 @@ public: * usec() methods. There is no analogous "millisecond" * component in an ACE_Time_Value. */ - unsigned long msec (void) const; + unsigned long msec () const; /// Converts from ACE_Time_Value format into milliseconds format. /** @@ -226,7 +226,7 @@ public: * @note The semantics of this method differs from the msec() * method. */ - time_t sec (void) const; + time_t sec () const; /// Set seconds. void sec (time_t sec); @@ -238,7 +238,7 @@ public: * @note The semantics of this method differs from the msec() * method. */ - suseconds_t usec (void) const; + suseconds_t usec () const; /// Set microseconds. void usec (suseconds_t usec); @@ -320,7 +320,7 @@ public: * @note The only reason this is here is to allow the use of ACE_Atomic_Op * with ACE_Time_Value. */ - ACE_Time_Value &operator++ (void); + ACE_Time_Value &operator++ (); /// Decrement microseconds as postfix. /** @@ -334,7 +334,7 @@ public: * @note The only reason this is here is to allow the use of ACE_Atomic_Op * with ACE_Time_Value. */ - ACE_Time_Value &operator-- (void); + ACE_Time_Value &operator-- (); /// Adds two ACE_Time_Value objects together, returns the sum. friend ACE_Export ACE_Time_Value operator + (const ACE_Time_Value &tv1, @@ -429,7 +429,7 @@ public: * violates layering restrictions in ACE because this class is part * of the OS layer and @c ACE_Log_Msg is at a higher level. */ - void dump (void) const; + void dump () const; # if defined (ACE_WIN32) /// Const time difference between FILETIME and POSIX time. diff --git a/ACE/ace/Time_Value.inl b/ACE/ace/Time_Value.inl index a06bd1be18d..ad683ae365d 100644 --- a/ACE/ace/Time_Value.inl +++ b/ACE/ace/Time_Value.inl @@ -101,7 +101,7 @@ ACE_Time_Value::set (const timespec_t &tv) } ACE_INLINE -ACE_Time_Value::ACE_Time_Value (void) +ACE_Time_Value::ACE_Time_Value () // : tv_ () { // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); @@ -117,7 +117,7 @@ ACE_Time_Value::ACE_Time_Value (time_t sec, suseconds_t usec) /// Returns number of seconds. ACE_INLINE time_t -ACE_Time_Value::sec (void) const +ACE_Time_Value::sec () const { // ACE_OS_TRACE ("ACE_Time_Value::sec"); return this->tv_.tv_sec; @@ -133,7 +133,7 @@ ACE_Time_Value::sec (time_t sec) /// Converts from Time_Value format into milli-seconds format. ACE_INLINE unsigned long -ACE_Time_Value::msec (void) const +ACE_Time_Value::msec () const { // ACE_OS_TRACE ("ACE_Time_Value::msec"); @@ -201,7 +201,7 @@ ACE_Time_Value::msec (int milliseconds) /// Returns number of micro-seconds. ACE_INLINE suseconds_t -ACE_Time_Value::usec (void) const +ACE_Time_Value::usec () const { // ACE_OS_TRACE ("ACE_Time_Value::usec"); return this->tv_.tv_usec; diff --git a/ACE/ace/Time_Value_T.h b/ACE/ace/Time_Value_T.h index 3cbdf84e480..c6f9a55b87a 100644 --- a/ACE/ace/Time_Value_T.h +++ b/ACE/ace/Time_Value_T.h @@ -38,7 +38,7 @@ public: typedef TIME_POLICY time_policy_t; /// Default Constructor. - ACE_Time_Value_T (void) {} + ACE_Time_Value_T () {} /// Constructor. explicit ACE_Time_Value_T (time_t sec, suseconds_t usec = 0) @@ -111,7 +111,7 @@ public: * @note The only reason this is here is to allow the use of ACE_Atomic_Op * with ACE_Time_Value. */ - ACE_Time_Value_T<TIME_POLICY> &operator++ (void); + ACE_Time_Value_T<TIME_POLICY> &operator++ (); /// Decrement microseconds as postfix. /** @@ -125,7 +125,7 @@ public: * @note The only reason this is here is to allow the use of ACE_Atomic_Op * with ACE_Time_Value. */ - ACE_Time_Value_T<TIME_POLICY> &operator-- (void); + ACE_Time_Value_T<TIME_POLICY> &operator-- (); /// Get current time of day according to time policy. /** diff --git a/ACE/ace/Time_Value_T.inl b/ACE/ace/Time_Value_T.inl index 934bebf228c..707ad994872 100644 --- a/ACE/ace/Time_Value_T.inl +++ b/ACE/ace/Time_Value_T.inl @@ -67,7 +67,7 @@ ACE_Time_Value_T<TIME_POLICY> ACE_Time_Value_T<TIME_POLICY>::operator++ (int) } template <class TIME_POLICY> -ACE_Time_Value_T<TIME_POLICY> &ACE_Time_Value_T<TIME_POLICY>::operator++ (void) +ACE_Time_Value_T<TIME_POLICY> &ACE_Time_Value_T<TIME_POLICY>::operator++ () { this->ACE_Time_Value::operator ++(); return *this; @@ -82,7 +82,7 @@ ACE_Time_Value_T<TIME_POLICY> ACE_Time_Value_T<TIME_POLICY>::operator-- (int) } template <class TIME_POLICY> -ACE_Time_Value_T<TIME_POLICY> &ACE_Time_Value_T<TIME_POLICY>::operator-- (void) +ACE_Time_Value_T<TIME_POLICY> &ACE_Time_Value_T<TIME_POLICY>::operator-- () { this->ACE_Time_Value::operator --(); return *this; diff --git a/ACE/ace/Unbounded_Queue.cpp b/ACE/ace/Unbounded_Queue.cpp index 02f96eeab5c..e12fd39327f 100644 --- a/ACE/ace/Unbounded_Queue.cpp +++ b/ACE/ace/Unbounded_Queue.cpp @@ -68,21 +68,21 @@ ACE_Unbounded_Queue<T>::operator= (const ACE_Unbounded_Queue<T> &us) } template <class T> ACE_Unbounded_Queue_Iterator<T> -ACE_Unbounded_Queue<T>::begin (void) +ACE_Unbounded_Queue<T>::begin () { // ACE_TRACE ("ACE_Unbounded_Queue<T>::begin"); return ACE_Unbounded_Queue_Iterator<T> (*this); } template <class T> ACE_Unbounded_Queue_Iterator<T> -ACE_Unbounded_Queue<T>::end (void) +ACE_Unbounded_Queue<T>::end () { // ACE_TRACE ("ACE_Unbounded_Queue<T>::end"); return ACE_Unbounded_Queue_Iterator<T> (*this, 1); } template <class T> void -ACE_Unbounded_Queue<T>::dump (void) const +ACE_Unbounded_Queue<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Queue<T>::dump"); @@ -118,7 +118,7 @@ ACE_Unbounded_Queue<T>::copy_nodes (const ACE_Unbounded_Queue<T> &us) } template <class T> void -ACE_Unbounded_Queue<T>::delete_nodes (void) +ACE_Unbounded_Queue<T>::delete_nodes () { for (ACE_Node<T> *curr = this->head_->next_; // Keep looking until we've hit the dummy node. @@ -143,7 +143,7 @@ ACE_Unbounded_Queue<T>::delete_nodes (void) } template <class T> -ACE_Unbounded_Queue<T>::~ACE_Unbounded_Queue (void) +ACE_Unbounded_Queue<T>::~ACE_Unbounded_Queue () { // ACE_TRACE ("ACE_Unbounded_Queue<T>::~ACE_Unbounded_Queue (void)"); @@ -224,7 +224,7 @@ ACE_Unbounded_Queue<T>::dequeue_head (T &item) } template <class T> void -ACE_Unbounded_Queue<T>::reset (void) +ACE_Unbounded_Queue<T>::reset () { ACE_TRACE ("reset"); @@ -319,7 +319,7 @@ ACE_Unbounded_Queue<T>::set (const T &item, // **************************************************************** template <class T> void -ACE_Unbounded_Queue_Const_Iterator<T>::dump (void) const +ACE_Unbounded_Queue_Const_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Queue_Const_Iterator<T>::dump"); @@ -335,7 +335,7 @@ ACE_Unbounded_Queue_Const_Iterator<T>::ACE_Unbounded_Queue_Const_Iterator (const } template <class T> int -ACE_Unbounded_Queue_Const_Iterator<T>::advance (void) +ACE_Unbounded_Queue_Const_Iterator<T>::advance () { // ACE_TRACE ("ACE_Unbounded_Queue_Const_Iterator<T>::advance"); this->current_ = this->current_->next_; @@ -343,7 +343,7 @@ ACE_Unbounded_Queue_Const_Iterator<T>::advance (void) } template <class T> int -ACE_Unbounded_Queue_Const_Iterator<T>::first (void) +ACE_Unbounded_Queue_Const_Iterator<T>::first () { // ACE_TRACE ("ACE_Unbounded_Queue_Const_Iterator<T>::first"); this->current_ = this->queue_.head_->next_; @@ -351,7 +351,7 @@ ACE_Unbounded_Queue_Const_Iterator<T>::first (void) } template <class T> int -ACE_Unbounded_Queue_Const_Iterator<T>::done (void) const +ACE_Unbounded_Queue_Const_Iterator<T>::done () const { ACE_TRACE ("ACE_Unbounded_Queue_Const_Iterator<T>::done"); @@ -374,7 +374,7 @@ ACE_Unbounded_Queue_Const_Iterator<T>::next (T *&item) // **************************************************************** template <class T> void -ACE_Unbounded_Queue_Iterator<T>::dump (void) const +ACE_Unbounded_Queue_Iterator<T>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Queue_Iterator<T>::dump"); @@ -390,7 +390,7 @@ ACE_Unbounded_Queue_Iterator<T>::ACE_Unbounded_Queue_Iterator (ACE_Unbounded_Que } template <class T> int -ACE_Unbounded_Queue_Iterator<T>::advance (void) +ACE_Unbounded_Queue_Iterator<T>::advance () { // ACE_TRACE ("ACE_Unbounded_Queue_Iterator<T>::advance"); this->current_ = this->current_->next_; @@ -398,7 +398,7 @@ ACE_Unbounded_Queue_Iterator<T>::advance (void) } template <class T> int -ACE_Unbounded_Queue_Iterator<T>::first (void) +ACE_Unbounded_Queue_Iterator<T>::first () { // ACE_TRACE ("ACE_Unbounded_Queue_Iterator<T>::first"); this->current_ = this->queue_.head_->next_; @@ -406,7 +406,7 @@ ACE_Unbounded_Queue_Iterator<T>::first (void) } template <class T> int -ACE_Unbounded_Queue_Iterator<T>::done (void) const +ACE_Unbounded_Queue_Iterator<T>::done () const { ACE_TRACE ("ACE_Unbounded_Queue_Iterator<T>::done"); diff --git a/ACE/ace/Unbounded_Queue.h b/ACE/ace/Unbounded_Queue.h index cb0c748f9df..172f0b84319 100644 --- a/ACE/ace/Unbounded_Queue.h +++ b/ACE/ace/Unbounded_Queue.h @@ -46,17 +46,17 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the queue have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the queue. Returns 0 if the /// queue is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -88,17 +88,17 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the queue have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the queue. Returns 0 if the /// queue is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; @@ -175,7 +175,7 @@ public: /** * Clean up the memory for the queue. */ - ~ACE_Unbounded_Queue (void); + ~ACE_Unbounded_Queue (); // = Check boundary conditions. @@ -183,13 +183,13 @@ public: /** * Constant time check to see if the queue is empty. */ - bool is_empty (void) const; + bool is_empty () const; /// Returns 0. /** * The queue cannot be full, so it always returns 0. */ - bool is_full (void) const; + bool is_full () const; // = Classic queue operations. @@ -221,7 +221,7 @@ public: /** * Delete the queue nodes. */ - void reset (void); + void reset (); /// Get the @a slot th element in the set. Returns -1 if the element /// isn't in the range {0..#cur_size_ - 1}, else 0. @@ -244,21 +244,21 @@ public: /** * Return the size of the queue. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL-styled unidirectional iterator factory. - ACE_Unbounded_Queue_Iterator<T> begin (void); - ACE_Unbounded_Queue_Iterator<T> end (void); + ACE_Unbounded_Queue_Iterator<T> begin (); + ACE_Unbounded_Queue_Iterator<T> end (); /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; protected: /// Delete all the nodes in the queue. - void delete_nodes (void); + void delete_nodes (); /// Copy nodes into this queue. void copy_nodes (const ACE_Unbounded_Queue<T> &); diff --git a/ACE/ace/Unbounded_Queue.inl b/ACE/ace/Unbounded_Queue.inl index b3e76ad999d..0ff0cecc476 100644 --- a/ACE/ace/Unbounded_Queue.inl +++ b/ACE/ace/Unbounded_Queue.inl @@ -2,20 +2,20 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class T> ACE_INLINE size_t -ACE_Unbounded_Queue<T>::size (void) const +ACE_Unbounded_Queue<T>::size () const { return this->cur_size_; } template <class T> ACE_INLINE bool -ACE_Unbounded_Queue<T>::is_empty (void) const +ACE_Unbounded_Queue<T>::is_empty () const { // ACE_TRACE ("ACE_Unbounded_Queue<T>::is_empty"); return this->head_ == this->head_->next_; } template <class T> ACE_INLINE bool -ACE_Unbounded_Queue<T>::is_full (void) const +ACE_Unbounded_Queue<T>::is_full () const { // ACE_TRACE ("ACE_Unbounded_Queue<T>::is_full"); return false; // We should implement a "node of last resort for this..." diff --git a/ACE/ace/Unbounded_Set_Ex.cpp b/ACE/ace/Unbounded_Set_Ex.cpp index d6460cef1c5..7e6ddafdc4a 100644 --- a/ACE/ace/Unbounded_Set_Ex.cpp +++ b/ACE/ace/Unbounded_Set_Ex.cpp @@ -18,7 +18,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex) template <class T, class C> size_t -ACE_Unbounded_Set_Ex<T, C>::size (void) const +ACE_Unbounded_Set_Ex<T, C>::size () const { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::size"); return this->cur_size_; @@ -49,7 +49,7 @@ ACE_Unbounded_Set_Ex<T, C>::insert_tail (const T &item) } template <class T, class C> void -ACE_Unbounded_Set_Ex<T, C>::reset (void) +ACE_Unbounded_Set_Ex<T, C>::reset () { ACE_TRACE ("reset"); @@ -57,7 +57,7 @@ ACE_Unbounded_Set_Ex<T, C>::reset (void) } template <class T, class C> void -ACE_Unbounded_Set_Ex<T, C>::dump (void) const +ACE_Unbounded_Set_Ex<T, C>::dump () const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::dump"); @@ -92,7 +92,7 @@ ACE_Unbounded_Set_Ex<T, C>::copy_nodes (const ACE_Unbounded_Set_Ex<T, C> &us) } template <class T, class C> void -ACE_Unbounded_Set_Ex<T, C>::delete_nodes (void) +ACE_Unbounded_Set_Ex<T, C>::delete_nodes () { NODE *curr = this->head_->next_; @@ -114,7 +114,7 @@ ACE_Unbounded_Set_Ex<T, C>::delete_nodes (void) } template <class T, class C> -ACE_Unbounded_Set_Ex<T, C>::~ACE_Unbounded_Set_Ex (void) +ACE_Unbounded_Set_Ex<T, C>::~ACE_Unbounded_Set_Ex () { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::~ACE_Unbounded_Set_Ex"); @@ -256,28 +256,28 @@ ACE_Unbounded_Set_Ex<T, C>::remove (const T &item) } template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::iterator -ACE_Unbounded_Set_Ex<T, C>::begin (void) +ACE_Unbounded_Set_Ex<T, C>::begin () { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::begin"); return iterator (*this); } template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::iterator -ACE_Unbounded_Set_Ex<T, C>::end (void) +ACE_Unbounded_Set_Ex<T, C>::end () { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::end"); return iterator (*this, 1); } template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::const_iterator -ACE_Unbounded_Set_Ex<T, C>::begin (void) const +ACE_Unbounded_Set_Ex<T, C>::begin () const { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::begin"); return const_iterator (*this); } template <class T, class C> typename ACE_Unbounded_Set_Ex<T, C>::const_iterator -ACE_Unbounded_Set_Ex<T, C>::end (void) const +ACE_Unbounded_Set_Ex<T, C>::end () const { // ACE_TRACE ("ACE_Unbounded_Set_Ex<T, C>::end"); return const_iterator (*this, 1); @@ -286,7 +286,7 @@ ACE_Unbounded_Set_Ex<T, C>::end (void) const ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex_Iterator) template <class T, class C> void -ACE_Unbounded_Set_Ex_Iterator<T, C>::dump (void) const +ACE_Unbounded_Set_Ex_Iterator<T, C>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::dump"); @@ -304,7 +304,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::ACE_Unbounded_Set_Ex_Iterator ( } template <class T, class C> int -ACE_Unbounded_Set_Ex_Iterator<T, C>::advance (void) +ACE_Unbounded_Set_Ex_Iterator<T, C>::advance () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::advance"); this->current_ = this->current_->next_; @@ -312,7 +312,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::advance (void) } template <class T, class C> int -ACE_Unbounded_Set_Ex_Iterator<T, C>::first (void) +ACE_Unbounded_Set_Ex_Iterator<T, C>::first () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::first"); this->current_ = this->set_->head_->next_; @@ -320,7 +320,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::first (void) } template <class T, class C> int -ACE_Unbounded_Set_Ex_Iterator<T, C>::done (void) const +ACE_Unbounded_Set_Ex_Iterator<T, C>::done () const { ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::done"); @@ -353,7 +353,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (int) } template <class T, class C> ACE_Unbounded_Set_Ex_Iterator<T, C>& -ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (void) +ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (void)"); @@ -364,7 +364,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::operator++ (void) } template <class T, class C> T& -ACE_Unbounded_Set_Ex_Iterator<T, C>::operator* (void) +ACE_Unbounded_Set_Ex_Iterator<T, C>::operator* () { //ACE_TRACE ("ACE_Unbounded_Set_Ex_Iterator<T, C>::operator*"); T *retv = 0; @@ -393,7 +393,7 @@ ACE_Unbounded_Set_Ex_Iterator<T, C>::operator!= (const ACE_Unbounded_Set_Ex_Iter ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unbounded_Set_Ex_Const_Iterator) template <class T, class C> void -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::dump (void) const +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::dump () const { #if defined (ACE_HAS_DUMP) // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::dump"); @@ -411,7 +411,7 @@ ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::ACE_Unbounded_Set_Ex_Const_Iterator ( } template <class T, class C> int -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance (void) +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance"); this->current_ = this->current_->next_; @@ -419,7 +419,7 @@ ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::advance (void) } template <class T, class C> int -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first (void) +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first"); this->current_ = this->set_->head_->next_; @@ -427,7 +427,7 @@ ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::first (void) } template <class T, class C> int -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::done (void) const +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::done () const { ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::done"); @@ -460,7 +460,7 @@ ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (int) } template <class T, class C> ACE_Unbounded_Set_Ex_Const_Iterator<T, C>& -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (void) +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ () { // ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (void)"); @@ -471,7 +471,7 @@ ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator++ (void) } template <class T, class C> T& -ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator* (void) +ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator* () { //ACE_TRACE ("ACE_Unbounded_Set_Ex_Const_Iterator<T, C>::operator*"); T *retv = 0; diff --git a/ACE/ace/Unbounded_Set_Ex.h b/ACE/ace/Unbounded_Set_Ex.h index 7d5a3a4b6e3..c59c1ec81ae 100644 --- a/ACE/ace/Unbounded_Set_Ex.h +++ b/ACE/ace/Unbounded_Set_Ex.h @@ -62,17 +62,17 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the set. Returns 0 if the /// set is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. @@ -80,10 +80,10 @@ public: ACE_Unbounded_Set_Ex_Iterator<T, C> operator++ (int); /// Prefix advance. - ACE_Unbounded_Set_Ex_Iterator<T, C>& operator++ (void); + ACE_Unbounded_Set_Ex_Iterator<T, C>& operator++ (); /// Returns a reference to the internal element @c this is pointing to. - T& operator* (void); + T& operator* (); /// Check if two iterators point to the same position bool operator== (const ACE_Unbounded_Set_Ex_Iterator<T, C> &) const; @@ -129,17 +129,17 @@ public: /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. - int advance (void); + int advance (); /// Move to the first element in the set. Returns 0 if the /// set is empty, else 1. - int first (void); + int first (); /// Returns 1 when all items have been seen, else 0. - int done (void) const; + int done () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; // = STL styled iteration, compare, and reference functions. @@ -147,10 +147,10 @@ public: ACE_Unbounded_Set_Ex_Const_Iterator<T, C> operator++ (int); /// Prefix advance. - ACE_Unbounded_Set_Ex_Const_Iterator<T, C>& operator++ (void); + ACE_Unbounded_Set_Ex_Const_Iterator<T, C>& operator++ (); /// Returns a reference to the internal element @c this is pointing to. - T& operator* (void); + T& operator* (); /// Check if two iterators point to the same position bool operator== (const ACE_Unbounded_Set_Ex_Const_Iterator<T, C> &) const; @@ -258,7 +258,7 @@ public: /** * Destroy the nodes of the set. */ - ~ACE_Unbounded_Set_Ex (void); + ~ACE_Unbounded_Set_Ex (); // = Check boundary conditions. @@ -266,13 +266,13 @@ public: /** * Constant time is_empty check. */ - bool is_empty (void) const; + bool is_empty () const; /// Returns @c false. /** * Always returns @c false since the set can never fill up. */ - bool is_full (void) const; + bool is_full () const; // = Classic unordered set operations. @@ -310,29 +310,29 @@ public: /** * Access the size of the set. */ - size_t size (void) const; + size_t size () const; /// Dump the state of an object. - void dump (void) const; + void dump () const; /// Reset the ACE_Unbounded_Set_Ex to be empty. /** * Delete the nodes of the set. */ - void reset (void); + void reset (); // = STL-styled unidirectional iterator factory. - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; + iterator begin (); + iterator end (); + const_iterator begin () const; + const_iterator end () const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; private: /// Delete all the nodes in the Set. - void delete_nodes (void); + void delete_nodes (); /// Copy nodes into this set. void copy_nodes (const ACE_Unbounded_Set_Ex<T, C> &); diff --git a/ACE/ace/Unbounded_Set_Ex.inl b/ACE/ace/Unbounded_Set_Ex.inl index bbb8772d6fc..65e8b67913f 100644 --- a/ACE/ace/Unbounded_Set_Ex.inl +++ b/ACE/ace/Unbounded_Set_Ex.inl @@ -4,14 +4,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL template <class T, class C> ACE_INLINE bool -ACE_Unbounded_Set_Ex<T,C>::is_empty (void) const +ACE_Unbounded_Set_Ex<T,C>::is_empty () const { ACE_TRACE ("ACE_Unbounded_Set_Ex<T>::is_empty"); return this->head_ == this->head_->next_; } template <class T, class C> ACE_INLINE bool -ACE_Unbounded_Set_Ex<T, C>::is_full (void) const +ACE_Unbounded_Set_Ex<T, C>::is_full () const { ACE_TRACE ("ACE_Unbounded_Set_Ex<T>::is_full"); return 0; // We should implement a "node of last resort for this..." diff --git a/ACE/ace/ace_wchar.h b/ACE/ace/ace_wchar.h index 7afc673328b..f6a73d9704f 100644 --- a/ACE/ace/ace_wchar.h +++ b/ACE/ace/ace_wchar.h @@ -150,10 +150,10 @@ public: ACE_Wide_To_Ascii (const wchar_t *s); /// Destructor will free up the memory. - ~ACE_Wide_To_Ascii (void); + ~ACE_Wide_To_Ascii (); /// Return the internal char* representation. - char *char_rep (void); + char *char_rep (); /// Converts an wchar_t string to ascii and returns a new string. static char *convert (const wchar_t *wstr); @@ -167,7 +167,7 @@ private: #endif /* ACE_HAS_ICONV */ /// Disallow these operation. - ACE_Wide_To_Ascii (void); + ACE_Wide_To_Ascii (); ACE_Wide_To_Ascii (ACE_Wide_To_Ascii &); ACE_Wide_To_Ascii& operator= (ACE_Wide_To_Ascii &); }; @@ -188,10 +188,10 @@ public: ACE_Ascii_To_Wide (const char *s); /// Destructor will free up the memory. - ~ACE_Ascii_To_Wide (void); + ~ACE_Ascii_To_Wide (); /// Return the internal wchar* representation. - wchar_t *wchar_rep (void); + wchar_t *wchar_rep (); /// Converts an char string to unicode/wide and returns a new string. static wchar_t *convert (const char *str); @@ -205,7 +205,7 @@ private: #endif /* ACE_HAS_ICONV */ /// Disallow these operation. - ACE_Ascii_To_Wide (void); + ACE_Ascii_To_Wide (); ACE_Ascii_To_Wide (ACE_Ascii_To_Wide &); ACE_Ascii_To_Wide operator= (ACE_Ascii_To_Wide &); }; diff --git a/ACE/ace/ace_wchar.inl b/ACE/ace/ace_wchar.inl index 438d6672dc8..752c177f680 100644 --- a/ACE/ace/ace_wchar.inl +++ b/ACE/ace/ace_wchar.inl @@ -11,13 +11,13 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL inline -ACE_Wide_To_Ascii::~ACE_Wide_To_Ascii (void) +ACE_Wide_To_Ascii::~ACE_Wide_To_Ascii () { delete [] this->s_; } inline char * -ACE_Wide_To_Ascii::char_rep (void) +ACE_Wide_To_Ascii::char_rep () { return this->s_; } @@ -101,13 +101,13 @@ ACE_Wide_To_Ascii::ACE_Wide_To_Ascii (const wchar_t *s) } inline -ACE_Ascii_To_Wide::~ACE_Ascii_To_Wide (void) +ACE_Ascii_To_Wide::~ACE_Ascii_To_Wide () { delete [] this->s_; } inline wchar_t * -ACE_Ascii_To_Wide::wchar_rep (void) +ACE_Ascii_To_Wide::wchar_rep () { return this->s_; } diff --git a/ACE/ace/config-lite.h b/ACE/ace/config-lite.h index 2b57e4697f7..27a63cf6ca9 100644 --- a/ACE/ace/config-lite.h +++ b/ACE/ace/config-lite.h @@ -46,7 +46,7 @@ ACE_END_VERSIONED_NAMESPACE_DECL // For use by <ACE_OS::exit>. extern "C" { - typedef void (*ACE_EXIT_HOOK) (void); + typedef void (*ACE_EXIT_HOOK) (); } // Signature for registering a cleanup function that is used by the @@ -83,11 +83,11 @@ typedef void (*ACE_INIT_LOG_MSG_HOOK) (ACE_OS_Log_Msg_Attributes &attr typedef void (*ACE_INHERIT_LOG_MSG_HOOK) (ACE_OS_Thread_Descriptor*, ACE_OS_Log_Msg_Attributes &); -typedef void (*ACE_CLOSE_LOG_MSG_HOOK) (void); +typedef void (*ACE_CLOSE_LOG_MSG_HOOK) (); typedef void (*ACE_SYNC_LOG_MSG_HOOK) (const ACE_TCHAR *prog_name); -typedef ACE_OS_Thread_Descriptor *(*ACE_THR_DESC_LOG_MSG_HOOK) (void); +typedef ACE_OS_Thread_Descriptor *(*ACE_THR_DESC_LOG_MSG_HOOK) (); ACE_END_VERSIONED_NAMESPACE_DECL |