*** empty log message ***

3 files changed, 196 insertions, 169 deletions

diff --git a/ChangeLog-99b b/ChangeLog-99b
index 451a14102f2..0c0a587505c 100644
--- a/ChangeLog-99b
+++ b/ChangeLog-99b
@@ -1,3 +1,9 @@
+Tue Mar 16 19:48:57 1999  Irfan Pyarali  <irfan@cs.wustl.edu>
+
+	* ace/Map_T.h (class ACE_Noop_Key_Generator): Added new class.
+	  This class makes it easy to use the map adapters when you don't
+	  care about generating new keys.
+
 Tue Mar 16 11:36:41 1999  Nanbor Wang  <nanbor@cs.wustl.edu>
 
 	* ace/config-freebsd-pthread.h: FreeBSD 2.2 and above also support
diff --git a/ace/Map_T.h b/ace/Map_T.h
index bb837f0cb37..fe1c9926fdb 100644
--- a/ace/Map_T.h
+++ b/ace/Map_T.h
@@ -30,6 +30,19 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
+class ACE_Noop_Key_Generator
+{
+  // = TITLE
+  //     Defines a noop key generator.
+public:
+
+  int operator() (T &);
+  // Functor method: generates a new key.
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
 class ACE_Incremental_Key_Generator
 {
   // = TITLE
diff --git a/ace/Map_T.i b/ace/Map_T.i
index 013b17feb18..ebf18482d8a 100644
--- a/ace/Map_T.i
+++ b/ace/Map_T.i
@@ -2,6 +2,14 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class T> ACE_INLINE int
+ACE_Noop_Key_Generator<T>::operator() (T &t)
+{
+  return -1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 template <class T> ACE_INLINE
 ACE_Incremental_Key_Generator<T>::ACE_Incremental_Key_Generator (void)
   : t_ (0)
@@ -48,7 +56,7 @@ ACE_Iterator<T>::ACE_Iterator (const ACE_Iterator<T> &rhs)
   : implementation_ (rhs.implementation_->clone ())
 {
 }
-  
+
 template <class T> ACE_INLINE
 ACE_Iterator<T>::~ACE_Iterator (void)
 {
@@ -63,13 +71,13 @@ ACE_Iterator<T>::operator= (const ACE_Iterator<T> &rhs)
   return *this;
 }
 
-template <class T> ACE_INLINE int 
+template <class T> ACE_INLINE int
 ACE_Iterator<T>::operator== (const ACE_Iterator<T> &rhs) const
 {
   return this->implementation_->compare (*rhs.implementation_);
 }
 
-template <class T> ACE_INLINE int 
+template <class T> ACE_INLINE int
 ACE_Iterator<T>::operator!= (const ACE_Iterator<T> &rhs) const
 {
   return !this->operator== (rhs);
@@ -88,7 +96,7 @@ ACE_Iterator<T>::operator++ (void)
   return *this;
 }
 
-template <class T> ACE_INLINE ACE_Iterator<T> 
+template <class T> ACE_INLINE ACE_Iterator<T>
 ACE_Iterator<T>::operator++ (int)
 {
   ACE_Iterator<T> tmp = *this;
@@ -103,7 +111,7 @@ ACE_Iterator<T>::operator-- (void)
   return *this;
 }
 
-template <class T> ACE_INLINE ACE_Iterator<T> 
+template <class T> ACE_INLINE ACE_Iterator<T>
 ACE_Iterator<T>::operator-- (int)
 {
   ACE_Iterator<T> tmp = *this;
@@ -130,7 +138,7 @@ ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rh
   : implementation_ (rhs.implementation_->clone ())
 {
 }
-  
+
 template <class T> ACE_INLINE
 ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator (void)
 {
@@ -145,13 +153,13 @@ ACE_Reverse_Iterator<T>::operator= (const ACE_Reverse_Iterator<T> &rhs)
   return *this;
 }
 
-template <class T> ACE_INLINE int 
+template <class T> ACE_INLINE int
 ACE_Reverse_Iterator<T>::operator== (const ACE_Reverse_Iterator<T> &rhs) const
 {
   return this->implementation_->compare (*rhs.implementation_);
 }
 
-template <class T> ACE_INLINE int 
+template <class T> ACE_INLINE int
 ACE_Reverse_Iterator<T>::operator!= (const ACE_Reverse_Iterator<T> &rhs) const
 {
   return !this->operator== (rhs);
@@ -170,7 +178,7 @@ ACE_Reverse_Iterator<T>::operator++ (void)
   return *this;
 }
 
-template <class T> ACE_INLINE ACE_Reverse_Iterator<T> 
+template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
 ACE_Reverse_Iterator<T>::operator++ (int)
 {
   ACE_Reverse_Iterator<T> tmp = *this;
@@ -185,7 +193,7 @@ ACE_Reverse_Iterator<T>::operator-- (void)
   return *this;
 }
 
-template <class T> ACE_INLINE ACE_Reverse_Iterator<T> 
+template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
 ACE_Reverse_Iterator<T>::operator-- (int)
 {
   ACE_Reverse_Iterator<T> tmp = *this;
@@ -201,12 +209,12 @@ ACE_Reverse_Iterator<T>::impl (void)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class KEY, class VALUE> ACE_INLINE 
+template <class KEY, class VALUE> ACE_INLINE
 ACE_Map<KEY, VALUE>::ACE_Map (void)
 {
 }
 
-template <class KEY, class VALUE> ACE_INLINE 
+template <class KEY, class VALUE> ACE_INLINE
 ACE_Map<KEY, VALUE>::~ACE_Map (void)
 {
 }
@@ -258,7 +266,7 @@ ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int
 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs 
+  const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs
     = ACE_dynamic_cast_3_ref (const ACE_Map_Impl_Iterator_Adapter, T, IMPLEMENTATION, ENTRY, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -313,7 +321,7 @@ ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) co
 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int
 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs 
+  const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs
     = ACE_dynamic_cast_3_ref (const ACE_Map_Impl_Reverse_Iterator_Adapter, T, IMPLEMENTATION, ENTRY, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -347,10 +355,10 @@ ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (ACE_Allocator *alloc)
   : implementation_ (alloc)
-{  
+{
 }
 
 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
@@ -370,47 +378,47 @@ template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class RE
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length,
                                                 ACE_Allocator *alloc)
 {
-  return this->implementation_.open (length, 
+  return this->implementation_.open (length,
                                      alloc);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void)
 {
   return this->implementation_.close ();
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key,
                                                 const VALUE &value)
 {
-  return this->implementation_.bind (key, 
+  return this->implementation_.bind (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value,
                                                            KEY &key)
 {
-  return this->implementation_.bind_modify_key (value, 
+  return this->implementation_.bind_modify_key (value,
                                                 key);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value,
                                                            KEY &key)
 {
-  return this->implementation_.bind_create_key (value, 
+  return this->implementation_.bind_create_key (value,
                                                 key);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value)
 {
   return this->implementation_.bind_create_key (value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key,
                                                        KEY &original_key)
 {
@@ -418,88 +426,88 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rec
                                             original_key);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                   const VALUE &value)
 {
-  return this->implementation_.rebind (key, 
+  return this->implementation_.rebind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                   const VALUE &value,
                                                   VALUE &old_value)
 {
-  return this->implementation_.rebind (key, 
-                                       value, 
+  return this->implementation_.rebind (key,
+                                       value,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                   const VALUE &value,
-                                                  KEY &old_key, 
+                                                  KEY &old_key,
                                                   VALUE &old_value)
 {
   return this->implementation_.rebind (key,
-                                       value, 
+                                       value,
                                        old_key,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key,
                                                    VALUE &value)
 {
-  return this->implementation_.trybind (key, 
+  return this->implementation_.trybind (key,
                                         value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
-ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key, 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
+ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key,
                                                 VALUE &value)
 {
   return this->implementation_.find (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key)
 {
   return this->implementation_.find (key);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key)
 {
   return this->implementation_.unbind (key);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int 
-ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key, 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int
+ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key,
                                                   VALUE &value)
 {
-  return this->implementation_.unbind (key, 
+  return this->implementation_.unbind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void)
 {
   return this->implementation_.current_size ();
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void)
 {
   return this->implementation_.total_size ();
 }
 
-template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE void 
+template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE void
 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const
 {
-  this->implementation_.dump ();  
+  this->implementation_.dump ();
 }
 
 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
@@ -555,7 +563,7 @@ ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const
 template <class T, class VALUE> ACE_INLINE int
 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs 
+  const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs
     = ACE_dynamic_cast_2_ref (const ACE_Active_Map_Manager_Iterator_Adapter, T, VALUE, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -610,7 +618,7 @@ ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const
 template <class T, class VALUE> ACE_INLINE int
 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs 
+  const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs
     = ACE_dynamic_cast_2_ref (const ACE_Active_Map_Manager_Reverse_Iterator_Adapter, T, VALUE, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -644,10 +652,10 @@ ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl (void)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc)
   : implementation_ (alloc)
-{  
+{
 }
 
 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
@@ -667,38 +675,38 @@ template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length,
                                                                ACE_Allocator *alloc)
 {
-  return this->implementation_.open (length, 
+  return this->implementation_.open (length,
                                      alloc);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void)
 {
   return this->implementation_.close ();
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &,
                                                                const VALUE &)
 {
   ACE_NOTSUP_RETURN (-1);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value,
                                                                           KEY &key)
 {
   // Reserve a slot and create an active key.
   expanded_value *internal_value = 0;
   ACE_Active_Map_Manager_Key active_key;
-  int result = this->implementation_.bind (active_key, 
+  int result = this->implementation_.bind (active_key,
                                            internal_value);
   if (result == 0)
     {
       // Encode the active key and the existing user key into key part
       // of <expanded_value>.
       result = this->key_adapter_.encode (key,
-                                          active_key, 
+                                          active_key,
                                           internal_value->first ());
       if (result == 0)
         {
@@ -717,20 +725,20 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value,
                                                                           KEY &key)
 {
   // Reserve a slot and create an active key.
   expanded_value *internal_value = 0;
   ACE_Active_Map_Manager_Key active_key;
-  int result = this->implementation_.bind (active_key, 
+  int result = this->implementation_.bind (active_key,
                                            internal_value);
   if (result == 0)
     {
       // Encode the active key into key part of <expanded_value>.
       result = this->key_adapter_.encode (internal_value->first (),
-                                          active_key, 
+                                          active_key,
                                           internal_value->first ());
       if (result == 0)
         {
@@ -749,13 +757,13 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value)
 {
   // Reserve a slot and create an active key.
   expanded_value *internal_value = 0;
   ACE_Active_Map_Manager_Key active_key;
-  int result = this->implementation_.bind (active_key, 
+  int result = this->implementation_.bind (active_key,
                                            internal_value);
   if (result == 0)
     {
@@ -778,7 +786,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key,
                                                                       KEY &original_key)
 {
@@ -788,7 +796,7 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY
                                     original_key);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
                                                                ACE_Pair<KEY, VALUE> *&internal_value)
 {
@@ -799,21 +807,21 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
   if (result == 0)
     {
       // Find recovered active key in map.
-      result = this->implementation_.find (active_key, 
+      result = this->implementation_.find (active_key,
                                            internal_value);
     }
-  
+
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
-ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key, 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
+ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
                                                                VALUE &value)
 {
   expanded_value *internal_value = 0;
-  int result = this->find (key, 
+  int result = this->find (key,
                            internal_value);
-              
+
   if (result == 0)
     {
       // Copy value.
@@ -823,22 +831,22 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key)
 {
   expanded_value *internal_value = 0;
-  return this->find (key, 
+  return this->find (key,
                      internal_value);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                  const VALUE &value)
 {
   expanded_value *internal_value = 0;
-  int result = this->find (key, 
+  int result = this->find (key,
                            internal_value);
-              
+
   if (result == 0)
     {
       // Reset value.
@@ -848,15 +856,15 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                  const VALUE &value,
                                                                  VALUE &old_value)
 {
   expanded_value *internal_value = 0;
-  int result = this->find (key, 
+  int result = this->find (key,
                            internal_value);
-              
+
   if (result == 0)
     {
       // Copy old value.
@@ -869,16 +877,16 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                  const VALUE &value,
-                                                                 KEY &old_key, 
+                                                                 KEY &old_key,
                                                                  VALUE &old_value)
 {
   expanded_value *internal_value = 0;
-  int result = this->find (key, 
+  int result = this->find (key,
                            internal_value);
-              
+
   if (result == 0)
     {
       // Copy old key and value.
@@ -892,14 +900,14 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &,
                                                                   VALUE &)
 {
   ACE_NOTSUP_RETURN (-1);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
                                                                  ACE_Pair<KEY, VALUE> *&internal_value)
 {
@@ -910,29 +918,29 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
   if (result == 0)
     {
       // Unbind recovered active key from map.
-      result = this->implementation_.unbind (active_key, 
+      result = this->implementation_.unbind (active_key,
                                              internal_value);
     }
-  
+
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key)
 {
   expanded_value *internal_value = 0;
-  return this->unbind (key, 
+  return this->unbind (key,
                        internal_value);
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int 
-ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int
+ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
                                                                  VALUE &value)
 {
   expanded_value *internal_value = 0;
-  int result = this->unbind (key, 
+  int result = this->unbind (key,
                              internal_value);
-              
+
   if (result == 0)
     {
       // Copy value.
@@ -942,22 +950,22 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void)
 {
   return this->implementation_.current_size ();
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void)
 {
   return this->implementation_.total_size ();
 }
 
-template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE void 
+template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE void
 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const
 {
-  this->implementation_.dump ();  
+  this->implementation_.dump ();
 }
 
 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
@@ -1019,7 +1027,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 int
 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs 
+  const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs
     = ACE_dynamic_cast_5_ref (const ACE_Hash_Map_Manager_Ex_Iterator_Adapter, T, KEY, VALUE, HASH_KEY, COMPARE_KEYS, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -1074,7 +1082,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 int
 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs 
+  const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs
     = ACE_dynamic_cast_5_ref (const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter, T, KEY, VALUE, HASH_KEY, COMPARE_KEYS, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -1108,10 +1116,10 @@ ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPAR
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc)
   : implementation_ (alloc)
-{  
+{
 }
 
 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
@@ -1131,58 +1139,58 @@ template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length,
                                                                                           ACE_Allocator *alloc)
 {
-  return this->implementation_.open (length, 
+  return this->implementation_.open (length,
                                      alloc);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void)
 {
   return this->implementation_.close ();
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key,
                                                                                           const VALUE &value)
 {
-  return this->implementation_.bind (key, 
+  return this->implementation_.bind (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
                                                                                                      KEY &key)
 {
-  return this->implementation_.bind (key, 
+  return this->implementation_.bind (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value,
                                                                                                      KEY &key)
 {
   // Invoke the user specified key generation functor.
   int result = this->key_generator_ (key);
-  
+
   if (result == 0)
     {
       // Try to add.
-      result = this->implementation_.bind (key, 
+      result = this->implementation_.bind (key,
                                            value);
     }
 
   return result;
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value)
 {
   KEY key;
-  return this->bind_create_key (value, 
+  return this->bind_create_key (value,
                                 key);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key,
                                                                                                  KEY &original_key)
 {
@@ -1190,88 +1198,88 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO
   return 0;
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                             const VALUE &value)
 {
-  return this->implementation_.rebind (key, 
+  return this->implementation_.rebind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                             const VALUE &value,
                                                                                             VALUE &old_value)
 {
-  return this->implementation_.rebind (key, 
-                                       value, 
+  return this->implementation_.rebind (key,
+                                       value,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                             const VALUE &value,
-                                                                                            KEY &old_key, 
+                                                                                            KEY &old_key,
                                                                                             VALUE &old_value)
 {
   return this->implementation_.rebind (key,
-                                       value, 
+                                       value,
                                        old_key,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key,
                                                                                              VALUE &value)
 {
-  return this->implementation_.trybind (key, 
+  return this->implementation_.trybind (key,
                                         value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
-ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key, 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
+ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key,
                                                                                           VALUE &value)
 {
   return this->implementation_.find (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key)
 {
   return this->implementation_.find (key);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key)
 {
   return this->implementation_.unbind (key);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int 
-ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key, 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int
+ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key,
                                                                                             VALUE &value)
 {
-  return this->implementation_.unbind (key, 
+  return this->implementation_.unbind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void)
 {
   return this->implementation_.current_size ();
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void)
 {
   return this->implementation_.total_size ();
 }
 
-template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE void 
+template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE void
 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const
 {
-  this->implementation_.dump ();  
+  this->implementation_.dump ();
 }
 
 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
@@ -1333,7 +1341,7 @@ ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
 template <class T, class KEY, class VALUE> ACE_INLINE int
 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs 
+  const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs
     = ACE_dynamic_cast_3_ref (const ACE_Map_Manager_Iterator_Adapter, T, KEY, VALUE, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -1388,7 +1396,7 @@ ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
 template <class T, class KEY, class VALUE> ACE_INLINE int
 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs_base) const
 {
-  const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs 
+  const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs
     = ACE_dynamic_cast_3_ref (const ACE_Map_Manager_Reverse_Iterator_Adapter, T, KEY, VALUE, rhs_base);
 
   return this->implementation_ == rhs.implementation_;
@@ -1422,10 +1430,10 @@ ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl (void)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (ACE_Allocator *alloc)
   : implementation_ (alloc)
-{  
+{
 }
 
 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
@@ -1445,50 +1453,50 @@ template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length,
                                                           ACE_Allocator *alloc)
 {
-  return this->implementation_.open (length, 
+  return this->implementation_.open (length,
                                      alloc);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void)
 {
   return this->implementation_.close ();
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key,
                                                           const VALUE &value)
 {
-  return this->implementation_.bind (key, 
+  return this->implementation_.bind (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
                                                                      KEY &key)
 {
-  return this->implementation_.bind (key, 
+  return this->implementation_.bind (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value,
                                                                      KEY &key)
 {
   // Invoke the user specified key generation functor.
   int result = this->key_generator_ (key);
-  
+
   if (result == 0)
     {
       // Try to add.
-      result = this->implementation_.bind (key, 
+      result = this->implementation_.bind (key,
                                            value);
     }
 
   return result;
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value)
 {
   KEY key;
@@ -1496,7 +1504,7 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE
                                 key);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key,
                                                                  KEY &original_key)
 {
@@ -1504,88 +1512,88 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modi
   return 0;
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                             const VALUE &value)
 {
-  return this->implementation_.rebind (key, 
+  return this->implementation_.rebind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                             const VALUE &value,
                                                             VALUE &old_value)
 {
-  return this->implementation_.rebind (key, 
-                                       value, 
+  return this->implementation_.rebind (key,
+                                       value,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                             const VALUE &value,
-                                                            KEY &old_key, 
+                                                            KEY &old_key,
                                                             VALUE &old_value)
 {
   return this->implementation_.rebind (key,
-                                       value, 
+                                       value,
                                        old_key,
                                        old_value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key,
                                                              VALUE &value)
 {
-  return this->implementation_.trybind (key, 
+  return this->implementation_.trybind (key,
                                         value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
-ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key, 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
+ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key,
                                                           VALUE &value)
 {
   return this->implementation_.find (key,
                                      value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key)
 {
   return this->implementation_.find (key);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key)
 {
   return this->implementation_.unbind (key);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int 
-ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key, 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int
+ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key,
                                                             VALUE &value)
 {
-  return this->implementation_.unbind (key, 
+  return this->implementation_.unbind (key,
                                        value);
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void)
 {
   return this->implementation_.current_size ();
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void)
 {
   return this->implementation_.total_size ();
 }
 
-template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE void 
+template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE void
 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const
 {
-  this->implementation_.dump ();  
+  this->implementation_.dump ();
 }
 
 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *