ChangeLogTag:Thu Feb 20 09:01:55 2003 Ossama Othman <ossama@uci.edu>

65 files changed, 1675 insertions, 708 deletions

diff --git a/ChangeLog b/ChangeLog
index c9ecb843414..52ef96a0ec2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,304 @@
+Thu Feb 20 09:01:55 2003  Ossama Othman  <ossama@uci.edu>
+
+	* ace/Acceptor.h:
+	* ace/Connector.h:
+
+	  No need to include "ace/Service_Config.h" and
+	  "ace/Svc_Handler.h".
+
+	  Include "ace/Synch_Options.h".  Necessitated by inter-header
+	  dependency reductions.
+
+	* ace/Acceptor.cpp:
+	* ace/Connector.cpp:
+
+	  Include "ace/Svc_Handler.h".  Necessitated by inter-header
+	  dependency reductions.
+
+	* ace/Atomic_Op.h:
+
+	  Fixed doxygen documentation.
+
+	* ace/Atomic_Op.i (operator++, operator--):
+
+	  Implement these post{in,de}crement operators in terms of their
+	  corresponding pre{in,de}crement operators to ensure consistent
+	  semantics.
+
+	* ace/Atomic_Op_T.h (mutex_, own_mutex_):
+
+	  Improved const-correctness by making these mutex members
+	  mutable.  This allows us to avoid casting away the constness.
+
+	* ace/Atomic_Op_T.i (operator==, operator>=, operator>):
+	  (operator<=, operator<, value, operator=):
+
+	  Do not cast away the constness of the mutex.  That hack is no
+	  longer necessary since the mutex is now mutable.
+
+	* ace/Basic_Types.h:
+
+	  Improved doxygen documentation.
+
+	  Moved endianness determination macros prior to ACE_U_LongLong
+	  class.
+
+	  (operator=):
+
+	  Added ACE_ULongLong assignment operator declarations that accept
+	  32 bit signed and unsigned integers.
+
+	  (operator++, operator--):
+
+	  Added missing ACE_ULongLong post{in,de}crement operator
+	  declarations.
+
+	  (data_):
+
+	  Make declaration order of lower and upper 32 bit members (lo_
+	  and hi_) of this structure dependant on the endianness of the
+	  platform.  This mimics what is done for the ACE_LongLong type
+	  in the ACE_CDR classes.
+
+	* ace/Basic_Types.i (operator=):
+
+	  Added ACE_ULongLong assignment operator implementation that
+	  accept 32 bit signed and unsigned integers.
+
+	  (operator++, operator--):
+
+	  Added missing ACE_ULongLong post{in,de}crement operator
+	  implementations.
+
+	* ace/CDR_Base.cpp (mb_align):
+
+	  Uninlined this method in order to reduce inter-header
+	  dependencies.
+
+	  (operator<, operator<=, operator>, operator>=, operator==):
+	  (operator!=):
+
+	  Added these missing operator for the ACE_LongLong type.
+
+	  (Float, operator=, operator!=):
+
+	  Fixed potential unused argument warnings for the Cray/UNICOS
+	  case.
+
+	* ace/CDR_Base.h:
+
+	  Include "ace/OS.h" instead of "ace/Message_Block.h", and forward
+	  declare ACE_Message_Block in order to reduce inter-header
+	  dependencies.
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including headers that
+	  contain those typedefs.
+
+	  (operator=):
+
+	  Added ACE_LongLong constructors assignment operators that accept
+	  32-bit integers.
+
+	  (operator==, operator!=, operator<=, operator<, operator>=):
+	  (operator>):
+
+	  Added these missing ACE_LongLong relation operators.
+
+	* ace/CDR_Base.inl (operator=):
+
+	  Added ACE_LongLong constructors assignment operators that accept
+	  32-bit integers.
+
+	  (operator==, operator!=, operator<=, operator<, operator>=):
+	  (operator>):
+
+	  Added these missing ACE_LongLong relation operators.
+
+	* ace/CDR_Stream.h:
+
+	  Moved definition of the ACE_CDR_BYTE_ORDER macros from OS.h to
+	  this header.  Helps with header dependency reduction.
+
+	* ace/Capabilities.h:
+
+	  Use ACE_Hash_Map_Manager_Ex instead of ACE_Hash_Map_Manager.
+	  Doing so saves us three template instantiations.
+
+	* ace/Capabilities.i:
+
+	  Cosmetic changes.
+
+	* ace/Capabilities.cpp:
+
+	  No need to include "ace/Map_Manager.h".
+
+	  Added missing ACE_RCSID macro.
+
+	  Improved conformance to ACE coding conventions.
+
+	  Removed explicit template instantiations for the
+	  ACE_Hash_Map_Manager template.  That template is no longer
+	  used.
+
+	  (reset_caps):
+
+	  Use ACE_Hash_Map_Manager_Ex template traits instead of the
+	  actual template type.  Makes for cleaner code.
+
+	* ace/Configuration.cpp:
+	* ace/Configuration.h:
+	* ace/Strategies_T.cpp:
+	* ace/Token_Collection.cpp:
+	* ace/Token_Collection.h:
+	* ace/Token_Invariants.cpp:
+	* ace/Token_Invariants.h:
+	* ace/Token_Manager.cpp:
+	* ace/Token_Manager.h:
+	* ace/WIN32_Asynch_IO.cpp:
+	* ace/WIN32_Asynch_IO.h:
+
+	  Take advantage of template traits to improve clarity of code.
+
+	* ace/Copy_Disabled.h:
+
+	  Corrected comment.
+
+	* ace/Default_Constants.h:
+
+	  Moved ACE_DEFAULT_CDR_BUFSIZE, ACE_DEFAULT_CDR_EXP_GROWTH_MAX,
+	  ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK,
+	  ACE_DEFAULT_CDR_MEMCPY_TRADEOFF macros from OS.h to this
+	  header.  Helps with inter-header dependency reduction.
+
+	* ace/Dynamic_Service_Base.cpp:
+	* ace/Parse_Node.cpp:
+	* ace/Service_Manager.cpp:
+	* ace/Service_Repository.cpp:
+	* ace/Svc_Conf.y:
+	* ace/Svc_Conf_y.cpp:
+
+	  Include "ace/Service_Types.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Filecache.h:
+	* ace/Filecache.cpp:
+	* ace/Hash_Map_With_Allocator_T.h:
+	* ace/Hash_Map_With_Allocator_T.cpp:
+	* ace/Local_Name_Space_T.h:
+	* ace/Local_Name_Space.cpp:
+
+	  Use ACE_Hash_Map_Manager_Ex instead of ACE_Hash_Map_Manager.
+	  Doing so saves us three template instantiations.
+
+	* ace/Future_Set.h:
+	* ace/Map_T.h:
+
+	  Include "ace/Hash_Map_Manager_T.h" instead of
+	  "ace/Hash_Map_Manager.h".  The former is all that is needed, and
+	  the latter already includes the former.
+
+	* ace/Hash_Map_Manager_T.i (operator++, operator--):
+	* ace/Map_Manager.i:
+	* ace/RB_Tree.i:
+
+	  Implement the post-{in,de}crement operators in terms of their
+	  pre-{in,de}crement operator counterparts to ensure consistency.
+
+	* ace/Local_Name_Space_T.cpp:
+
+	  No need to include "ace/Auto_Ptr.h"
+
+	  Use template traits to improve code clarity.
+
+	* ace/OS.h:
+
+	  Moved ACE_CDR_BYTE_ORDER macro definition to CDR_Stream.h.
+	  Helps with inter-header dependencies.
+
+	  Moved ACE_DEFAULT_CDR_BUFSIZE, ACE_DEFAULT_CDR_EXP_GROWTH_MAX,
+	  ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK,
+	  ACE_DEFAULT_CDR_MEMCPY_TRADEOFF to Default_Constants.h.  Helps
+	  with inter-header dependency reduction.
+
+	* ace/POSIX_Asynch_IO.cpp:
+
+	  Added missing ACE_RCSID macro.
+
+	  (bytes_transferred):
+	  Use map template traits to improve code clarity.
+	
+	* ace/POSIX_Asynch_IO.h:
+
+	  Redefined old map typedefs in terms of the map traits.
+
+	* ace/Parse_Node.h:
+	* ace/Service_Repository.h:
+
+	  No need to include "ace/Service_Types.h".  A forward declaration
+	  for ACE_Service_Types is enough.
+
+	* ace/Service_Config.h:
+
+	  No need to include "ace/Service_Types.h" and "ace/Signal.h".
+	  Forward declaring ACE_Service_Types and ACE_Sig_Adapter is
+	  enough.
+
+	* ace/Strategies_T.h:
+
+	  No need to include "ace/Service_Config.h" and
+	  "ace/Synch_Options.h".
+
+	* ace/Synch_Options.h:
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including OS.h.  A big win in
+	  compile time reduction.
+
+	  Include "ace/Time_Value.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Synch_Options.cpp:
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including OS.h.  A big win in
+	  compile time reduction.
+
+	  Include "ace/Trace.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Template_Instantiations.cpp:
+
+	  Removed all ACE_Hash_Map_Manager related template
+	  instantiations.  The ones for ACE_Hash_Map_Manager_Ex are all
+	  that are needed.
+
+	* ace/SSL/SSL_SOCK_Acceptor.h (ACE_SSL_SOCK_Acceptor):
+
+	  Inherit privately from ACE_SSL_SOCK, instead of publically.
+	  ACE_SSL_SOCK_Acceptor is IMPLEMENTED-IN-TERMS-OF ACE_SSL_SOCK.
+	  It does not satisfy the IS-A relationship.
+
+	* ace/SSL/SSL_SOCK_Connector.cpp (ssl_connect):
+
+	  Use ACE_Countdown_Time to take into account the time between
+	  each call to select() instead of using the same timeout value in
+	  each loop iteration.
+
+	* ace/SSL/SSL_SOCK_Stream.cpp (get_remote_addr):
+
+	  Retrieve the remote addr from the parent ACE_SSL_SOCK class, not
+	  ACE_SOCK.  Addresses potential inconsistencies in the future.
+
+	* ace/SSL/SSL_SOCK_Stream.h (ACE_SSL_SOCK_Stream):
+
+	  Removed friend declarations for the
+	  ACE_SSL_SOCK_{Acceptor,Connector} classes.  They are
+	  unnecessary.
+
 Wed Feb 19 12:50:58 2003  Heather Drury  <oci@cs.wustl.edu>
 
         * ACE version 5.3.1 released.
diff --git a/ChangeLogs/ChangeLog-03a b/ChangeLogs/ChangeLog-03a
index c9ecb843414..52ef96a0ec2 100644
--- a/ChangeLogs/ChangeLog-03a
+++ b/ChangeLogs/ChangeLog-03a
@@ -1,3 +1,304 @@
+Thu Feb 20 09:01:55 2003  Ossama Othman  <ossama@uci.edu>
+
+	* ace/Acceptor.h:
+	* ace/Connector.h:
+
+	  No need to include "ace/Service_Config.h" and
+	  "ace/Svc_Handler.h".
+
+	  Include "ace/Synch_Options.h".  Necessitated by inter-header
+	  dependency reductions.
+
+	* ace/Acceptor.cpp:
+	* ace/Connector.cpp:
+
+	  Include "ace/Svc_Handler.h".  Necessitated by inter-header
+	  dependency reductions.
+
+	* ace/Atomic_Op.h:
+
+	  Fixed doxygen documentation.
+
+	* ace/Atomic_Op.i (operator++, operator--):
+
+	  Implement these post{in,de}crement operators in terms of their
+	  corresponding pre{in,de}crement operators to ensure consistent
+	  semantics.
+
+	* ace/Atomic_Op_T.h (mutex_, own_mutex_):
+
+	  Improved const-correctness by making these mutex members
+	  mutable.  This allows us to avoid casting away the constness.
+
+	* ace/Atomic_Op_T.i (operator==, operator>=, operator>):
+	  (operator<=, operator<, value, operator=):
+
+	  Do not cast away the constness of the mutex.  That hack is no
+	  longer necessary since the mutex is now mutable.
+
+	* ace/Basic_Types.h:
+
+	  Improved doxygen documentation.
+
+	  Moved endianness determination macros prior to ACE_U_LongLong
+	  class.
+
+	  (operator=):
+
+	  Added ACE_ULongLong assignment operator declarations that accept
+	  32 bit signed and unsigned integers.
+
+	  (operator++, operator--):
+
+	  Added missing ACE_ULongLong post{in,de}crement operator
+	  declarations.
+
+	  (data_):
+
+	  Make declaration order of lower and upper 32 bit members (lo_
+	  and hi_) of this structure dependant on the endianness of the
+	  platform.  This mimics what is done for the ACE_LongLong type
+	  in the ACE_CDR classes.
+
+	* ace/Basic_Types.i (operator=):
+
+	  Added ACE_ULongLong assignment operator implementation that
+	  accept 32 bit signed and unsigned integers.
+
+	  (operator++, operator--):
+
+	  Added missing ACE_ULongLong post{in,de}crement operator
+	  implementations.
+
+	* ace/CDR_Base.cpp (mb_align):
+
+	  Uninlined this method in order to reduce inter-header
+	  dependencies.
+
+	  (operator<, operator<=, operator>, operator>=, operator==):
+	  (operator!=):
+
+	  Added these missing operator for the ACE_LongLong type.
+
+	  (Float, operator=, operator!=):
+
+	  Fixed potential unused argument warnings for the Cray/UNICOS
+	  case.
+
+	* ace/CDR_Base.h:
+
+	  Include "ace/OS.h" instead of "ace/Message_Block.h", and forward
+	  declare ACE_Message_Block in order to reduce inter-header
+	  dependencies.
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including headers that
+	  contain those typedefs.
+
+	  (operator=):
+
+	  Added ACE_LongLong constructors assignment operators that accept
+	  32-bit integers.
+
+	  (operator==, operator!=, operator<=, operator<, operator>=):
+	  (operator>):
+
+	  Added these missing ACE_LongLong relation operators.
+
+	* ace/CDR_Base.inl (operator=):
+
+	  Added ACE_LongLong constructors assignment operators that accept
+	  32-bit integers.
+
+	  (operator==, operator!=, operator<=, operator<, operator>=):
+	  (operator>):
+
+	  Added these missing ACE_LongLong relation operators.
+
+	* ace/CDR_Stream.h:
+
+	  Moved definition of the ACE_CDR_BYTE_ORDER macros from OS.h to
+	  this header.  Helps with header dependency reduction.
+
+	* ace/Capabilities.h:
+
+	  Use ACE_Hash_Map_Manager_Ex instead of ACE_Hash_Map_Manager.
+	  Doing so saves us three template instantiations.
+
+	* ace/Capabilities.i:
+
+	  Cosmetic changes.
+
+	* ace/Capabilities.cpp:
+
+	  No need to include "ace/Map_Manager.h".
+
+	  Added missing ACE_RCSID macro.
+
+	  Improved conformance to ACE coding conventions.
+
+	  Removed explicit template instantiations for the
+	  ACE_Hash_Map_Manager template.  That template is no longer
+	  used.
+
+	  (reset_caps):
+
+	  Use ACE_Hash_Map_Manager_Ex template traits instead of the
+	  actual template type.  Makes for cleaner code.
+
+	* ace/Configuration.cpp:
+	* ace/Configuration.h:
+	* ace/Strategies_T.cpp:
+	* ace/Token_Collection.cpp:
+	* ace/Token_Collection.h:
+	* ace/Token_Invariants.cpp:
+	* ace/Token_Invariants.h:
+	* ace/Token_Manager.cpp:
+	* ace/Token_Manager.h:
+	* ace/WIN32_Asynch_IO.cpp:
+	* ace/WIN32_Asynch_IO.h:
+
+	  Take advantage of template traits to improve clarity of code.
+
+	* ace/Copy_Disabled.h:
+
+	  Corrected comment.
+
+	* ace/Default_Constants.h:
+
+	  Moved ACE_DEFAULT_CDR_BUFSIZE, ACE_DEFAULT_CDR_EXP_GROWTH_MAX,
+	  ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK,
+	  ACE_DEFAULT_CDR_MEMCPY_TRADEOFF macros from OS.h to this
+	  header.  Helps with inter-header dependency reduction.
+
+	* ace/Dynamic_Service_Base.cpp:
+	* ace/Parse_Node.cpp:
+	* ace/Service_Manager.cpp:
+	* ace/Service_Repository.cpp:
+	* ace/Svc_Conf.y:
+	* ace/Svc_Conf_y.cpp:
+
+	  Include "ace/Service_Types.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Filecache.h:
+	* ace/Filecache.cpp:
+	* ace/Hash_Map_With_Allocator_T.h:
+	* ace/Hash_Map_With_Allocator_T.cpp:
+	* ace/Local_Name_Space_T.h:
+	* ace/Local_Name_Space.cpp:
+
+	  Use ACE_Hash_Map_Manager_Ex instead of ACE_Hash_Map_Manager.
+	  Doing so saves us three template instantiations.
+
+	* ace/Future_Set.h:
+	* ace/Map_T.h:
+
+	  Include "ace/Hash_Map_Manager_T.h" instead of
+	  "ace/Hash_Map_Manager.h".  The former is all that is needed, and
+	  the latter already includes the former.
+
+	* ace/Hash_Map_Manager_T.i (operator++, operator--):
+	* ace/Map_Manager.i:
+	* ace/RB_Tree.i:
+
+	  Implement the post-{in,de}crement operators in terms of their
+	  pre-{in,de}crement operator counterparts to ensure consistency.
+
+	* ace/Local_Name_Space_T.cpp:
+
+	  No need to include "ace/Auto_Ptr.h"
+
+	  Use template traits to improve code clarity.
+
+	* ace/OS.h:
+
+	  Moved ACE_CDR_BYTE_ORDER macro definition to CDR_Stream.h.
+	  Helps with inter-header dependencies.
+
+	  Moved ACE_DEFAULT_CDR_BUFSIZE, ACE_DEFAULT_CDR_EXP_GROWTH_MAX,
+	  ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK,
+	  ACE_DEFAULT_CDR_MEMCPY_TRADEOFF to Default_Constants.h.  Helps
+	  with inter-header dependency reduction.
+
+	* ace/POSIX_Asynch_IO.cpp:
+
+	  Added missing ACE_RCSID macro.
+
+	  (bytes_transferred):
+	  Use map template traits to improve code clarity.
+	
+	* ace/POSIX_Asynch_IO.h:
+
+	  Redefined old map typedefs in terms of the map traits.
+
+	* ace/Parse_Node.h:
+	* ace/Service_Repository.h:
+
+	  No need to include "ace/Service_Types.h".  A forward declaration
+	  for ACE_Service_Types is enough.
+
+	* ace/Service_Config.h:
+
+	  No need to include "ace/Service_Types.h" and "ace/Signal.h".
+	  Forward declaring ACE_Service_Types and ACE_Sig_Adapter is
+	  enough.
+
+	* ace/Strategies_T.h:
+
+	  No need to include "ace/Service_Config.h" and
+	  "ace/Synch_Options.h".
+
+	* ace/Synch_Options.h:
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including OS.h.  A big win in
+	  compile time reduction.
+
+	  Include "ace/Time_Value.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Synch_Options.cpp:
+
+	  Changed all uses of typedefs like "u_char" and "u_long" to their
+	  non-typedef counterparts, e.g. "unsigned char" and "unsigned
+	  long".  Makes it possible to avoid including OS.h.  A big win in
+	  compile time reduction.
+
+	  Include "ace/Trace.h".  Necessitated by inter-header
+	  dependency reduction.
+
+	* ace/Template_Instantiations.cpp:
+
+	  Removed all ACE_Hash_Map_Manager related template
+	  instantiations.  The ones for ACE_Hash_Map_Manager_Ex are all
+	  that are needed.
+
+	* ace/SSL/SSL_SOCK_Acceptor.h (ACE_SSL_SOCK_Acceptor):
+
+	  Inherit privately from ACE_SSL_SOCK, instead of publically.
+	  ACE_SSL_SOCK_Acceptor is IMPLEMENTED-IN-TERMS-OF ACE_SSL_SOCK.
+	  It does not satisfy the IS-A relationship.
+
+	* ace/SSL/SSL_SOCK_Connector.cpp (ssl_connect):
+
+	  Use ACE_Countdown_Time to take into account the time between
+	  each call to select() instead of using the same timeout value in
+	  each loop iteration.
+
+	* ace/SSL/SSL_SOCK_Stream.cpp (get_remote_addr):
+
+	  Retrieve the remote addr from the parent ACE_SSL_SOCK class, not
+	  ACE_SOCK.  Addresses potential inconsistencies in the future.
+
+	* ace/SSL/SSL_SOCK_Stream.h (ACE_SSL_SOCK_Stream):
+
+	  Removed friend declarations for the
+	  ACE_SSL_SOCK_{Acceptor,Connector} classes.  They are
+	  unnecessary.
+
 Wed Feb 19 12:50:58 2003  Heather Drury  <oci@cs.wustl.edu>
 
         * ACE version 5.3.1 released.
diff --git a/ace/Acceptor.cpp b/ace/Acceptor.cpp
index 35970cd85a7..be79daa6857 100644
--- a/ace/Acceptor.cpp
+++ b/ace/Acceptor.cpp
@@ -1,7 +1,5 @@
-// $Id$
-
-#ifndef ACE_ACCEPTOR_C
-#define ACE_ACCEPTOR_C
+#ifndef ACE_ACCEPTOR_CPP
+#define ACE_ACCEPTOR_CPP
 
 #include "ace/ACE.h"
 
@@ -11,9 +9,13 @@
 
 #include "ace/Acceptor.h"
 #include "ace/Handle_Set.h"
+#include "ace/Svc_Handler.h"
 #include "ace/WFMO_Reactor.h"
 
-ACE_RCSID(ace, Acceptor, "$Id$")
+
+ACE_RCSID (ace,
+           Acceptor,
+           "$Id$")
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Acceptor)
 
@@ -1208,4 +1210,4 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPT
   return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
 }
 
-#endif /* ACE_ACCEPTOR_C */
+#endif /* ACE_ACCEPTOR_CPP */
diff --git a/ace/Acceptor.h b/ace/Acceptor.h
index e04604ca697..aeef0c069af 100644
--- a/ace/Acceptor.h
+++ b/ace/Acceptor.h
@@ -15,15 +15,15 @@
 
 #include "ace/pre.h"
 
-#include "ace/Service_Config.h"
+#include "ace/Service_Object.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/Service_Object.h"
-#include "ace/Svc_Handler.h"
 #include "ace/Strategies_T.h"
+#include "ace/Synch_Options.h"
+
 
 /**
  * @class ACE_Acceptor
diff --git a/ace/Atomic_Op.h b/ace/Atomic_Op.h
index 07fa649bcd7..086fc7da3bd 100644
--- a/ace/Atomic_Op.h
+++ b/ace/Atomic_Op.h
@@ -50,7 +50,10 @@ ACE_TEMPLATE_SPECIALIZATION
  * @class ACE_Atomic_Op<ACE_Thread_Mutex, long>
  *
  * @brief Specialization of ACE_Atomic_Op for platforms that
- * support atomic integer operations.
+ *        support atomic integer operations.
+ *
+ * Specialization of ACE_Atomic_Op for platforms that support atomic
+ * integer operations.
  */
 class ACE_Export ACE_Atomic_Op<ACE_Thread_Mutex, long>
 {
diff --git a/ace/Atomic_Op.i b/ace/Atomic_Op.i
index a13caa5e178..39d09ba0d17 100644
--- a/ace/Atomic_Op.i
+++ b/ace/Atomic_Op.i
@@ -1,4 +1,5 @@
 // -*- C++ -*-
+//
 // $Id$
 
 
@@ -17,7 +18,8 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (long c)
 }
 
 ACE_INLINE
-ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
+ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (
+  const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
   : value_ (rhs.value_)
 {
 }
@@ -35,11 +37,7 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (void)
 ACE_INLINE long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (int)
 {
-#if defined (WIN32)
-  return ::InterlockedIncrement (ACE_const_cast (long *, &this->value_)) - 1;
-#else /* WIN32 */
-  return (*increment_fn_) (&this->value_) - 1;
-#endif /* WIN32 */
+  return ++*this - 1;
 }
 
 ACE_INLINE long
@@ -55,18 +53,15 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (void)
 ACE_INLINE long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (int)
 {
-#if defined (WIN32)
-  return ::InterlockedDecrement (ACE_const_cast (long *, &this->value_)) + 1;
-#else /* WIN32 */
-  return (*decrement_fn_) (&this->value_) + 1;
-#endif /* WIN32 */
+  return --*this + 1;
 }
 
 ACE_INLINE long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator+= (long rhs)
 {
 #if defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
-  return ::InterlockedExchangeAdd (ACE_const_cast (long *, &this->value_), rhs) + rhs;
+  return ::InterlockedExchangeAdd (ACE_const_cast (long *, &this->value_),
+                                   rhs) + rhs;
 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
   return (*exchange_add_fn_) (&this->value_, rhs) + rhs;
 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
@@ -76,7 +71,8 @@ ACE_INLINE long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-= (long rhs)
 {
 #if defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
-  return ::InterlockedExchangeAdd (ACE_const_cast (long *, &this->value_), -rhs) - rhs;
+  return ::InterlockedExchangeAdd (ACE_const_cast (long *, &this->value_),
+                                   -rhs) - rhs;
 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
   return (*exchange_add_fn_) (&this->value_, -rhs) - rhs;
 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
@@ -125,7 +121,8 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
 }
 
 ACE_INLINE void
-ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
+ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (
+   const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
 {
   this->value_ = rhs.value_;
 }
diff --git a/ace/Atomic_Op_T.h b/ace/Atomic_Op_T.h
index 47f9c9bce28..51d1ba93666 100644
--- a/ace/Atomic_Op_T.h
+++ b/ace/Atomic_Op_T.h
@@ -128,7 +128,7 @@ public:
 
 private:
   /// Type of synchronization mechanism.
-  ACE_LOCK &mutex_;
+  mutable ACE_LOCK &mutex_;
 
   /// Current object decorated by the atomic op.
   TYPE value_;
@@ -231,7 +231,7 @@ public:
 
 private:
   /// Type of synchronization mechanism.
-  ACE_LOCK own_mutex_;
+  mutable ACE_LOCK own_mutex_;
 
   /// Underlying atomic op implementation.
   ACE_Atomic_Op_Ex <ACE_LOCK, TYPE> impl_;
diff --git a/ace/Atomic_Op_T.i b/ace/Atomic_Op_T.i
index cd303e43864..098e30b58e1 100644
--- a/ace/Atomic_Op_T.i
+++ b/ace/Atomic_Op_T.i
@@ -65,7 +65,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE int
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator== (const TYPE &rhs) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator==");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, 0);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0);
   return this->value_ == rhs;
 }
 
@@ -80,7 +80,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE int
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>= (const TYPE &rhs) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>=");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, 0);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0);
   return this->value_ >= rhs;
 }
 
@@ -88,7 +88,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE int
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator> (const TYPE &rhs) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator>");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, 0);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0);
   return this->value_ > rhs;
 }
 
@@ -96,7 +96,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE int
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<= (const TYPE &rhs) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<=");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, 0);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0);
   return this->value_ <= rhs;
 }
 
@@ -104,7 +104,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE int
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator< (const TYPE &rhs) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator<");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, 0);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0);
   return this->value_ < rhs;
 }
 
@@ -125,7 +125,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE TYPE
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value (void) const
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::value");
-  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_, this->value_);
+  ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_);
   return this->value_;
 }
 
@@ -143,7 +143,7 @@ template <class ACE_LOCK, class TYPE> ACE_INLINE void
 ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator= (const TYPE &rhs)
 {
 // ACE_TRACE ("ACE_Atomic_Op_Ex<ACE_LOCK, TYPE>::operator=");
-  ACE_GUARD (ACE_LOCK, ace_mon, (ACE_LOCK &) this->mutex_);
+  ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_);
   this->value_ = rhs;
 }
 
diff --git a/ace/Basic_Types.h b/ace/Basic_Types.h
index af9ab727892..d843c1ecac3 100644
--- a/ace/Basic_Types.h
+++ b/ace/Basic_Types.h
@@ -276,6 +276,52 @@ typedef unsigned char ACE_Byte;
 # error "Can't find a suitable type for doing pointer arithmetic."
 #endif /* ACE_SIZEOF_VOID_P */
 
+// Byte-order (endian-ness) determination.
+# if defined (BYTE_ORDER)
+#   if (BYTE_ORDER == LITTLE_ENDIAN)
+#     define ACE_LITTLE_ENDIAN 0x0123
+#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
+#   elif (BYTE_ORDER == BIG_ENDIAN)
+#     define ACE_BIG_ENDIAN 0x3210
+#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
+#   else
+#     error: unknown BYTE_ORDER!
+#   endif /* BYTE_ORDER */
+# elif defined (_BYTE_ORDER)
+#   if (_BYTE_ORDER == _LITTLE_ENDIAN)
+#     define ACE_LITTLE_ENDIAN 0x0123
+#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
+#   elif (_BYTE_ORDER == _BIG_ENDIAN)
+#     define ACE_BIG_ENDIAN 0x3210
+#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
+#   else
+#     error: unknown _BYTE_ORDER!
+#   endif /* _BYTE_ORDER */
+# elif defined (__BYTE_ORDER)
+#   if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#     define ACE_LITTLE_ENDIAN 0x0123
+#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
+#   elif (__BYTE_ORDER == __BIG_ENDIAN)
+#     define ACE_BIG_ENDIAN 0x3210
+#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
+#   else
+#     error: unknown __BYTE_ORDER!
+#   endif /* __BYTE_ORDER */
+# else /* ! BYTE_ORDER && ! __BYTE_ORDER */
+  // We weren't explicitly told, so we have to figure it out . . .
+#   if defined (i386) || defined (__i386__) || defined (_M_IX86) || \
+     defined (vax) || defined (__alpha) || defined (__LITTLE_ENDIAN__) ||\
+     defined (ARM) || defined (_M_IA64)
+    // We know these are little endian.
+#     define ACE_LITTLE_ENDIAN 0x0123
+#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
+#   else
+    // Otherwise, we assume big endian.
+#     define ACE_BIG_ENDIAN 0x3210
+#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
+#   endif
+# endif /* ! BYTE_ORDER && ! __BYTE_ORDER */
+
 #if defined (ACE_LACKS_LONGLONG_T)
   // This throws away the high 32 bits.  It's very unlikely that a
   // pointer will be more than 32 bits wide if the platform does not
@@ -318,6 +364,8 @@ typedef unsigned char ACE_Byte;
     ACE_U_LongLong (const ACE_UINT32 lo = 0x0, const ACE_UINT32 hi = 0x0);
     ACE_U_LongLong (const ACE_U_LongLong &);
     ACE_U_LongLong &operator= (const ACE_U_LongLong &);
+    ACE_U_LongLong &operator= (const ACE_INT32 &);
+    ACE_U_LongLong &operator= (const ACE_UINT32 &);
     ~ACE_U_LongLong (void);
 
     // = Overloaded relation operators.
@@ -354,6 +402,8 @@ typedef unsigned char ACE_Byte;
     ACE_U_LongLong &operator-= (const ACE_UINT32);
     ACE_U_LongLong &operator++ ();
     ACE_U_LongLong &operator-- ();
+    ACE_U_LongLong operator++ (int);
+    ACE_U_LongLong operator-- (int);
     ACE_U_LongLong &operator|= (const ACE_U_LongLong);
     ACE_U_LongLong &operator|= (const ACE_UINT32);
     ACE_U_LongLong &operator&= (const ACE_U_LongLong);
@@ -404,18 +454,28 @@ typedef unsigned char ACE_Byte;
       {
         struct
           {
+#     if defined (ACE_BIG_ENDIAN)
+            /// High 32 bits.
             ACE_UINT32 hi_;
-            // High 32 bits.
 
+            /// Low 32 bits.
             ACE_UINT32 lo_;
-            // Low 32 bits.
+#     else
+            /// Low 32 bits.
+            ACE_UINT32 lo_;
+
+            /// High 32 bits.
+            ACE_UINT32 hi_;
+#     endif /* ! ACE_BIG_ENDIAN */
+
           } data_;
-        // To ensure alignment on 8-byte boundary.
 
-        // double isn't usually usable with ACE_LACKS_FLOATING_POINT,
-        // but this seems OK.
+        /// To ensure alignment on 8-byte boundary.
+        /**
+         * @note "double" isn't usually usable with
+         *       ACE_LACKS_FLOATING_POINT, but this seems OK.
+         */
         double for_alignment_;
-        // To ensure alignment on 8-byte boundary.
       };
 
     // NOTE:  the following four accessors are inlined here in
@@ -592,52 +652,6 @@ typedef unsigned char ACE_Byte;
 #define ACE_FLT_MAX 3.402823466e+38F
 #define ACE_DBL_MAX 1.7976931348623158e+308
 
-// Byte-order (endian-ness) determination.
-# if defined (BYTE_ORDER)
-#   if (BYTE_ORDER == LITTLE_ENDIAN)
-#     define ACE_LITTLE_ENDIAN 0x0123
-#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
-#   elif (BYTE_ORDER == BIG_ENDIAN)
-#     define ACE_BIG_ENDIAN 0x3210
-#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
-#   else
-#     error: unknown BYTE_ORDER!
-#   endif /* BYTE_ORDER */
-# elif defined (_BYTE_ORDER)
-#   if (_BYTE_ORDER == _LITTLE_ENDIAN)
-#     define ACE_LITTLE_ENDIAN 0x0123
-#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
-#   elif (_BYTE_ORDER == _BIG_ENDIAN)
-#     define ACE_BIG_ENDIAN 0x3210
-#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
-#   else
-#     error: unknown _BYTE_ORDER!
-#   endif /* _BYTE_ORDER */
-# elif defined (__BYTE_ORDER)
-#   if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#     define ACE_LITTLE_ENDIAN 0x0123
-#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
-#   elif (__BYTE_ORDER == __BIG_ENDIAN)
-#     define ACE_BIG_ENDIAN 0x3210
-#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
-#   else
-#     error: unknown __BYTE_ORDER!
-#   endif /* __BYTE_ORDER */
-# else /* ! BYTE_ORDER && ! __BYTE_ORDER */
-  // We weren't explicitly told, so we have to figure it out . . .
-#   if defined (i386) || defined (__i386__) || defined (_M_IX86) || \
-     defined (vax) || defined (__alpha) || defined (__LITTLE_ENDIAN__) ||\
-     defined (ARM) || defined (_M_IA64)
-    // We know these are little endian.
-#     define ACE_LITTLE_ENDIAN 0x0123
-#     define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN
-#   else
-    // Otherwise, we assume big endian.
-#     define ACE_BIG_ENDIAN 0x3210
-#     define ACE_BYTE_ORDER ACE_BIG_ENDIAN
-#   endif
-# endif /* ! BYTE_ORDER && ! __BYTE_ORDER */
-
 #if !defined (ACE_HAS_SSIZE_T)
 #  if defined (ACE_WIN64)
   typedef SSIZE_T ssize_t;
diff --git a/ace/Basic_Types.i b/ace/Basic_Types.i
index 0012b00defb..d0858fa03b7 100644
--- a/ace/Basic_Types.i
+++ b/ace/Basic_Types.i
@@ -1,4 +1,5 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
+//
 // $Id$
 
 #if defined (ACE_LACKS_LONGLONG_T)
@@ -135,6 +136,37 @@ ACE_U_LongLong::operator= (const ACE_U_LongLong &n)
   return *this;
 }
 
+ACE_INLINE ACE_U_LongLong &
+ACE_U_LongLong::operator= (const ACE_INT32 &rhs)
+{
+  if (rhs >= 0)
+    {
+      l_ () = ACE_static_cast (ACE_UINT32, rhs);
+      h_ () = 0;
+    }
+  else
+    {
+      // We do not handle the case where a negative 32 bit integer is
+      // assigned to this representation of a 64 bit unsigned integer.
+      // The "undefined behavior" behavior performed by this
+      // implementation is to simply set all bits to zero.
+      l_ () = 0;
+      h_ () = 0;
+    }
+
+  return *this;
+}
+
+ACE_INLINE ACE_U_LongLong &
+ACE_U_LongLong::operator= (const ACE_UINT32 &rhs)
+{
+  l_ () = rhs;
+  h_ () = 0;
+
+  return *this;
+}
+
+
 ACE_INLINE ACE_U_LongLong
 ACE_U_LongLong::operator+ (const ACE_U_LongLong &n) const
 {
@@ -358,6 +390,26 @@ ACE_U_LongLong::operator-- ()
   return *this;
 }
 
+ACE_INLINE const ACE_U_LongLong
+ACE_U_LongLong::operator++ (int)
+{
+  // Post-increment operator should always be implemented in terms of
+  // the pre-increment operator to enforce consistent semantics.
+  ACE_U_LongLong temp (*this);
+  ++*this;
+  return *temp;
+}
+
+ACE_INLINE const ACE_U_LongLong
+ACE_U_LongLong::operator-- (int)
+{
+  // Post-decrement operator should always be implemented in terms of
+  // the pre-decrement operator to enforce consistent semantics.
+  ACE_U_LongLong temp (*this);
+  --*this;
+  return *temp;
+}
+
 ACE_INLINE ACE_U_LongLong &
 ACE_U_LongLong::operator|= (const ACE_U_LongLong n)
 {
diff --git a/ace/CDR_Base.cpp b/ace/CDR_Base.cpp
index c01c3e40039..64f1e3472f4 100644
--- a/ace/CDR_Base.cpp
+++ b/ace/CDR_Base.cpp
@@ -1,7 +1,3 @@
-// -*- C++ -*-
-//
-// $Id$
-
 #include "ace/CDR_Base.h"
 #include "ace/Message_Block.h"
 
@@ -9,11 +5,12 @@
 # include "ace/CDR_Base.inl"
 #endif /* ! __ACE_INLINE__ */
 
-ACE_RCSID(ace, CDR_Base, "$Id$")
-
+ACE_RCSID (ace,
+           CDR_Base,
+           "$Id$")
 
 //
-// See comments in CDR_Base.i about optimization cases for swap_XX_array.
+// See comments in CDR_Base.inl about optimization cases for swap_XX_array.
 //
 
 void
@@ -24,7 +21,7 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
   // Later, we try to read in 32 or 64 bit chunks,
   // so make sure we don't do that for unaligned addresses.
 #if ACE_SIZEOF_LONG == 8
-  const char* const o8 = ACE_ptr_align_binary(orig, 8);
+  const char* const o8 = ACE_ptr_align_binary (orig, 8);
   while (orig < o8 && n > 0)
     {
       ACE_CDR::swap_2 (orig, target);
@@ -33,7 +30,7 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
       --n;
     }
 #else
-  const char* const o4 = ACE_ptr_align_binary(orig, 4);
+  const char* const o4 = ACE_ptr_align_binary (orig, 4);
   // this is an _if_, not a _while_. The mistmatch can only be by 2.
   if (orig != o4)
     {
@@ -54,28 +51,28 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
   // In the while loop ahead, orig will move over the array by 8 byte
   // increments (4 elements of 2 bytes).
   // end marks our barrier for not falling outside.
-  const char* const end = orig + 2*(n & (~3));
+  const char* const end = orig + 2 * (n & (~3));
 
   // See if we're aligned for writting in 64 or 32 bit chunks...
 #if ACE_SIZEOF_LONG == 8
-  if (target == ACE_ptr_align_binary(target, 8))
+  if (target == ACE_ptr_align_binary (target, 8))
 #else
-  if (target == ACE_ptr_align_binary(target, 4))
+  if (target == ACE_ptr_align_binary (target, 4))
 #endif
     {
       while (orig < end)
         {
-#if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
+#if defined (ACE_HAS_PENTIUM) && defined (__GNUG__)
           unsigned int a =
-            * ACE_reinterpret_cast(const unsigned int*, orig);
+            * ACE_reinterpret_cast (const unsigned int*, orig);
           unsigned int b =
-            * ACE_reinterpret_cast(const unsigned int*, orig + 4);
-          asm( "bswap %1"      : "=r" (a) : "0" (a) );
-          asm( "bswap %1"      : "=r" (b) : "0" (b) );
-          asm( "rol $16, %1"   : "=r" (a) : "0" (a) );
-          asm( "rol $16, %1"   : "=r" (b) : "0" (b) );
-          * ACE_reinterpret_cast(unsigned int*, target) = a;
-          * ACE_reinterpret_cast(unsigned int*, target + 4) = b;
+            * ACE_reinterpret_cast (const unsigned int*, orig + 4);
+          asm ( "bswap %1"      : "=r" (a) : "0" (a) );
+          asm ( "bswap %1"      : "=r" (b) : "0" (b) );
+          asm ( "rol $16, %1"   : "=r" (a) : "0" (a) );
+          asm ( "rol $16, %1"   : "=r" (b) : "0" (b) );
+          * ACE_reinterpret_cast (unsigned int*, target) = a;
+          * ACE_reinterpret_cast (unsigned int*, target + 4) = b;
 #elif defined(ACE_HAS_PENTIUM) \
       && (defined(_MSC_VER) || defined(__BORLANDC__)) \
       && !defined(ACE_LACKS_INLINE_ASSEMBLY)
@@ -92,19 +89,19 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
 #elif ACE_SIZEOF_LONG == 8
           // 64 bit architecture.
           register unsigned long a =
-            * ACE_reinterpret_cast(const unsigned long*, orig);
+            * ACE_reinterpret_cast (const unsigned long*, orig);
 
           register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8;
           register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8;
 
           a = (a1 | a2);
 
-          * ACE_reinterpret_cast(unsigned long*, target) = a;
+          * ACE_reinterpret_cast (unsigned long*, target) = a;
 #else
           register ACE_UINT32 a =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig);
           register ACE_UINT32 b =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
 
           register ACE_UINT32 a1 = (a & 0x00ff00ffU) << 8;
           register ACE_UINT32 b1 = (b & 0x00ff00ffU) << 8;
@@ -114,8 +111,8 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
           a = (a1 | a2);
           b = (b1 | b2);
 
-          * ACE_reinterpret_cast(ACE_UINT32*, target) = a;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b;
+          * ACE_reinterpret_cast (ACE_UINT32*, target) = a;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = b;
 #endif
           orig += 8;
           target += 8;
@@ -126,27 +123,27 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
       // We're out of luck. We have to write in 2 byte chunks.
       while (orig < end)
         {
-#if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
+#if defined (ACE_HAS_PENTIUM) && defined (__GNUG__)
           unsigned int a =
-            * ACE_reinterpret_cast(const unsigned int*, orig);
+            * ACE_reinterpret_cast (const unsigned int*, orig);
           unsigned int b =
-            * ACE_reinterpret_cast(const unsigned int*, orig + 4);
-          asm( "bswap %1" : "=r" (a) : "0" (a) );
-          asm( "bswap %1" : "=r" (b) : "0" (b) );
+            * ACE_reinterpret_cast (const unsigned int*, orig + 4);
+          asm ( "bswap %1" : "=r" (a) : "0" (a) );
+          asm ( "bswap %1" : "=r" (b) : "0" (b) );
           // We're little endian.
-          * ACE_reinterpret_cast(unsigned short*, target + 2)
+          * ACE_reinterpret_cast (unsigned short*, target + 2)
               = (unsigned short) (a & 0xffff);
-          * ACE_reinterpret_cast(unsigned short*, target + 6)
+          * ACE_reinterpret_cast (unsigned short*, target + 6)
               = (unsigned short) (b & 0xffff);
-          asm( "shrl $16, %1" : "=r" (a) : "0" (a) );
-          asm( "shrl $16, %1" : "=r" (b) : "0" (b) );
-          * ACE_reinterpret_cast(unsigned short*, target + 0)
+          asm ( "shrl $16, %1" : "=r" (a) : "0" (a) );
+          asm ( "shrl $16, %1" : "=r" (b) : "0" (b) );
+          * ACE_reinterpret_cast (unsigned short*, target + 0)
               = (unsigned short) (a & 0xffff);
-          * ACE_reinterpret_cast(unsigned short*, target + 4)
+          * ACE_reinterpret_cast (unsigned short*, target + 4)
               = (unsigned short) (b & 0xffff);
-#elif defined(ACE_HAS_PENTIUM) \
-      && (defined(_MSC_VER) || defined(__BORLANDC__)) \
-      && !defined(ACE_LACKS_INLINE_ASSEMBLY)
+#elif defined (ACE_HAS_PENTIUM) \
+      && (defined (_MSC_VER) || defined (__BORLANDC__)) \
+      && !defined (ACE_LACKS_INLINE_ASSEMBLY)
           __asm mov ecx, orig;
           __asm mov edx, target;
           __asm mov eax, [ecx];
@@ -163,34 +160,34 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
 #elif ACE_SIZEOF_LONG == 8
           // 64 bit architecture.
           register unsigned long a =
-            * ACE_reinterpret_cast(const unsigned long*, orig);
+            * ACE_reinterpret_cast (const unsigned long*, orig);
 
           register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8;
           register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8;
 
           a = (a1 | a2);
 
-          ACE_UINT16 b1 = ACE_static_cast(ACE_UINT16, (a >> 48));
-          ACE_UINT16 b2 = ACE_static_cast(ACE_UINT16, ((a >> 32) & 0xffff));
-          ACE_UINT16 b3 = ACE_static_cast(ACE_UINT16, ((a >> 16) & 0xffff));
-          ACE_UINT16 b4 = ACE_static_cast(ACE_UINT16, (a & 0xffff));
+          ACE_UINT16 b1 = ACE_static_cast (ACE_UINT16, (a >> 48));
+          ACE_UINT16 b2 = ACE_static_cast (ACE_UINT16, ((a >> 32) & 0xffff));
+          ACE_UINT16 b3 = ACE_static_cast (ACE_UINT16, ((a >> 16) & 0xffff));
+          ACE_UINT16 b4 = ACE_static_cast (ACE_UINT16, (a & 0xffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = b4;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = b4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = b3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = b2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = b1;
 #else
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = b1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = b1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = b2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = b3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = b4;
 #endif
 #else
           register ACE_UINT32 a =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig);
           register ACE_UINT32 b =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
 
           register ACE_UINT32 a1 = (a & 0x00ff00ff) << 8;
           register ACE_UINT32 b1 = (b & 0x00ff00ff) << 8;
@@ -200,21 +197,21 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
           a = (a1 | a2);
           b = (b1 | b2);
 
-          ACE_UINT32 c1 = ACE_static_cast(ACE_UINT16, (a >> 16));
-          ACE_UINT32 c2 = ACE_static_cast(ACE_UINT16, (a & 0xffff));
-          ACE_UINT32 c3 = ACE_static_cast(ACE_UINT16, (b >> 16));
-          ACE_UINT32 c4 = ACE_static_cast(ACE_UINT16, (b & 0xffff));
+          ACE_UINT32 c1 = ACE_static_cast (ACE_UINT16, (a >> 16));
+          ACE_UINT32 c2 = ACE_static_cast (ACE_UINT16, (a & 0xffff));
+          ACE_UINT32 c3 = ACE_static_cast (ACE_UINT16, (b >> 16));
+          ACE_UINT32 c4 = ACE_static_cast (ACE_UINT16, (b & 0xffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = c2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c4;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = c2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = c1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = c4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = c3;
 #else
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = c1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = c1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = c2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = c3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = c4;
 #endif
 #endif
 
@@ -277,9 +274,9 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       while (orig < end)
         {
           register unsigned long a =
-            * ACE_reinterpret_cast(const long*, orig);
+            * ACE_reinterpret_cast (const long*, orig);
           register unsigned long b =
-            * ACE_reinterpret_cast(const long*, orig + 8);
+            * ACE_reinterpret_cast (const long*, orig + 8);
 
           register unsigned long a84 = (a & 0x000000ff000000ffL) << 24;
           register unsigned long b84 = (b & 0x000000ff000000ffL) << 24;
@@ -293,8 +290,8 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
           a = (a84 | a73 | a62 | a51);
           b = (b84 | b73 | b62 | b51);
 
-          * ACE_reinterpret_cast(long*, target) = a;
-          * ACE_reinterpret_cast(long*, target + 8) = b;
+          * ACE_reinterpret_cast (long*, target) = a;
+          * ACE_reinterpret_cast (long*, target + 8) = b;
 
           orig += 16;
           target += 16;
@@ -306,9 +303,9 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       while (orig < end)
         {
           register unsigned long a =
-            * ACE_reinterpret_cast(const long*, orig);
+            * ACE_reinterpret_cast (const long*, orig);
           register unsigned long b =
-            * ACE_reinterpret_cast(const long*, orig + 8);
+            * ACE_reinterpret_cast (const long*, orig + 8);
 
           register unsigned long a84 = (a & 0x000000ff000000ffL) << 24;
           register unsigned long b84 = (b & 0x000000ff000000ffL) << 24;
@@ -322,21 +319,21 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
           a = (a84 | a73 | a62 | a51);
           b = (b84 | b73 | b62 | b51);
 
-          ACE_UINT32 c1 = ACE_static_cast(ACE_UINT32, (a >> 32));
-          ACE_UINT32 c2 = ACE_static_cast(ACE_UINT32, (a & 0xffffffff));
-          ACE_UINT32 c3 = ACE_static_cast(ACE_UINT32, (b >> 32));
-          ACE_UINT32 c4 = ACE_static_cast(ACE_UINT32, (b & 0xffffffff));
+          ACE_UINT32 c1 = ACE_static_cast (ACE_UINT32, (a >> 32));
+          ACE_UINT32 c2 = ACE_static_cast (ACE_UINT32, (a & 0xffffffff));
+          ACE_UINT32 c3 = ACE_static_cast (ACE_UINT32, (b >> 32));
+          ACE_UINT32 c4 = ACE_static_cast (ACE_UINT32, (b & 0xffffffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c2;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c1;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c4;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c3;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 0) = c2;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = c1;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c4;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = c3;
 #else
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c1;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c2;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c3;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c4;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 0) = c1;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = c2;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c3;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = c4;
 #endif
           orig += 16;
           target += 16;
@@ -349,23 +346,23 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
     {
 #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
       register unsigned int a =
-        *ACE_reinterpret_cast(const unsigned int*, orig);
+        *ACE_reinterpret_cast (const unsigned int*, orig);
       register unsigned int b =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 4);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 4);
       register unsigned int c =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 8);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 8);
       register unsigned int d =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 12);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 12);
 
       asm ("bswap %1" : "=r" (a) : "0" (a));
       asm ("bswap %1" : "=r" (b) : "0" (b));
       asm ("bswap %1" : "=r" (c) : "0" (c));
       asm ("bswap %1" : "=r" (d) : "0" (d));
 
-      *ACE_reinterpret_cast(unsigned int*, target) = a;
-      *ACE_reinterpret_cast(unsigned int*, target + 4) = b;
-      *ACE_reinterpret_cast(unsigned int*, target + 8) = c;
-      *ACE_reinterpret_cast(unsigned int*, target + 12) = d;
+      *ACE_reinterpret_cast (unsigned int*, target) = a;
+      *ACE_reinterpret_cast (unsigned int*, target + 4) = b;
+      *ACE_reinterpret_cast (unsigned int*, target + 8) = c;
+      *ACE_reinterpret_cast (unsigned int*, target + 12) = d;
 #elif defined(ACE_HAS_PENTIUM) \
       && (defined(_MSC_VER) || defined(__BORLANDC__)) \
       && !defined(ACE_LACKS_INLINE_ASSEMBLY)
@@ -385,13 +382,13 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       __asm mov 12[esi], eax
 #else
       register ACE_UINT32 a =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig);
       register ACE_UINT32 b =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
       register ACE_UINT32 c =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 8);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 8);
       register ACE_UINT32 d =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 12);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 12);
 
       // Expect the optimizer reordering this A LOT.
       // We leave it this way for clarity.
@@ -400,10 +397,10 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       c = (c << 24) | ((c & 0xff00) << 8) | ((c & 0xff0000) >> 8) | (c >> 24);
       d = (d << 24) | ((d & 0xff00) << 8) | ((d & 0xff0000) >> 8) | (d >> 24);
 
-      * ACE_reinterpret_cast(ACE_UINT32*, target) = a;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = d;
+      * ACE_reinterpret_cast (ACE_UINT32*, target) = a;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = b;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = d;
 #endif
 
       orig += 16;
@@ -439,7 +436,7 @@ ACE_CDR::swap_8_array (const char* orig, char* target, size_t n)
   const char* const end = orig + 8*n;
   while (orig < end)
     {
-      swap_8(orig, target);
+      swap_8 (orig, target);
       orig += 8;
       target += 8;
     }
@@ -453,12 +450,21 @@ ACE_CDR::swap_16_array (const char* orig, char* target, size_t n)
   const char* const end = orig + 16*n;
   while (orig < end)
     {
-      swap_16(orig, target);
+      swap_16 (orig, target);
       orig += 16;
       target += 16;
     }
 }
 
+void
+ACE_CDR::mb_align (ACE_Message_Block *mb)
+{
+  char *start = ACE_ptr_align_binary (mb->base (),
+                                      ACE_CDR::MAX_ALIGNMENT);
+  mb->rd_ptr (start);
+  mb->wr_ptr (start);
+}
+
 int
 ACE_CDR::grow (ACE_Message_Block *mb, size_t minsize)
 {
@@ -545,6 +551,100 @@ ACE_CDR::LongLong::operator!= (const ACE_CDR::LongLong &rhs) const
 {
   return this->l != rhs.l || this->h != rhs.h;
 }
+
+int
+ACE_CDR::LongLong::operator< (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h < rhs.h && this->l < rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator<= (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h <= rhs.h && this->l <= rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator> (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h > rhs.h && this->l > rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator>= (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h >= rhs.h && this->l >= rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator== (ACE_INT32 rhs) const
+{
+  // Do the right comparison based on the higher order bits.  Those
+  // bits indicate whether or not this LongLong is positive or
+  // negative.
+  if ((this->h == 0 && rhs >= 0) || (this->h == 0xFFFFFFFF && rhs < 0))
+    return this->l == rhs;
+  else
+    return 0;  // *this and rhs have different signs, or *this
+               // contains value that cannot be represented with 32
+               // bits alone.
+}
+
+int
+ACE_CDR::LongLong::operator!= (ACE_INT32 rhs) const
+{
+  // Do the right comparison based on the higher order bits.  Those
+  // bits indicate whether or not this LongLong is positive or
+  // negative.
+  if ((this->h == 0 && rhs >= 0) || (this->h == 0xFFFFFFFF && rhs < 0))
+    return this->l != rhs;
+  else
+    return 1;  // *this and rhs have different signs, or *this
+               // contains a value that cannot be represented with 32
+               // bits alone.
+}
+
+int
+ACE_CDR::LongLong::operator< (ACE_UINT32 rhs) const
+{
+  if (this->h > 0)
+    return 0;  // 64 bit positive number
+
+  else if (this->h < 0)
+    return 1;  // 64 bit negative number
+
+  else  // this->h == 0
+    return ACE_static_cast (ACE_UINT32, this->l) < rhs;  // 32 bit
+                                                         // positive
+                                                         // number
+}
+
+int
+ACE_CDR::LongLong::operator<= (ACE_UINT32 rhs) const
+{
+
+}
+
+int
+ACE_CDR::LongLong::operator> (ACE_UINT32 rhs) const
+{
+  if (this->h > 0)
+    return 1;  // A positive number with greater than
+
+  else if (this->h < 0)
+    return 0;  // 64 bit negative number
+
+  else  // this->h == 0
+    return ACE_static_cast (ACE_UINT32, this->l) > rhs;  // 32 bit
+                                                         // positive
+                                                         // number
+}
+
+int
+ACE_CDR::LongLong::operator>= (ACE_UINT32 rhs) const
+{
+  return this->l >= rhs;
+}
 #endif /* NONNATIVE_LONGLONG */
 
 #if defined (NONNATIVE_LONGDOUBLE)
@@ -563,22 +663,22 @@ ACE_CDR::LongDouble::operator!= (const ACE_CDR::LongDouble &rhs) const
 
 #if defined(_UNICOS) && !defined(_CRAYMPP)
 // placeholders to get things compiling
-ACE_CDR::Float::Float()
+ACE_CDR::Float::Float (void)
 {
 }
 
-ACE_CDR::Float::Float(const float & init)
+ACE_CDR::Float::Float (const float & /* init */)
 {
 }
 
 ACE_CDR::Float &
-ACE_CDR::Float::operator= (const float &rhs)
+ACE_CDR::Float::operator= (const float & /* rhs */)
 {
   return *this;
 }
 
 int
-ACE_CDR::Float::operator!= (const ACE_CDR::Float &rhs) const
+ACE_CDR::Float::operator!= (const ACE_CDR::Float & /* rhs */) const
 {
   return 0;
 }
diff --git a/ace/CDR_Base.h b/ace/CDR_Base.h
index 869708c1221..0a6326aa701 100644
--- a/ace/CDR_Base.h
+++ b/ace/CDR_Base.h
@@ -37,7 +37,10 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE	*/
 
 #include "ace/Basic_Types.h"
-#include "ace/Message_Block.h"
+#include "ace/OS.h"
+
+
+class ACE_Message_Block;
 
 /**
  * @class ACE_CDR
@@ -163,10 +166,10 @@ public:
     // Green Hills C++68000 1.8.8 forces us into it.
     typedef unsigned long Boolean;
 #  else	 /* ! (CHORUS && ghs 1.8.8) */
-    typedef u_char Boolean;
+    typedef unsigned char Boolean;
 #  endif /* ! (CHORUS && ghs 1.8.8) */
 
-  typedef u_char Octet;
+  typedef unsigned char Octet;
   typedef char Char;
   typedef ACE_OS::WChar	WChar;
   typedef ACE_INT16 Short;
@@ -192,23 +195,43 @@ public:
 #     endif /* sun */
 #   else  /* no	native 64 bit integer type */
 #     define NONNATIVE_LONGLONG
+      struct ACE_Export LongLong 
+        {
 #     if defined (ACE_BIG_ENDIAN)
-	      struct ACE_Export LongLong 
-        { 
           ACE_CDR::Long	h;
-          ACE_CDR::Long l; 
-          int operator== (const LongLong &rhs) const;
-          int operator!= (const LongLong &rhs) const;
-        };
+          ACE_CDR::Long l;
 #     else
-	      struct ACE_Export LongLong 
-        { 
           ACE_CDR::Long	l;
-          ACE_CDR::Long h; 
+          ACE_CDR::Long h;
+#     endif /* ! ACE_BIG_ENDIAN	*/
+
+          LongLong (const ACE_INT32);
+          LongLong (const ACE_UINT32);
+
+          void operator= (ACE_CDR::Long rhs);
+          void operator= (ACE_CDR::ULong rhs);
+
+          /**
+           * @name Overloaded Relation Operators.
+           *
+           * The canonical comparison operators.
+           */
+          //@{
           int operator== (const LongLong &rhs) const;
           int operator!= (const LongLong &rhs) const;
+          int operator< (const ACE_CDR::LongLong &) const;
+          int operator<= (const ACE_CDR::LongLong &) const;
+          int operator> (const ACE_CDR::LongLong &) const;
+          int operator>= (const ACE_CDR::LongLong &) const;
+
+          int operator== (ACE_UINT32) const;
+          int operator!= (ACE_UINT32) const;
+          int operator< (ACE_UINT32) const;
+          int operator<= (ACE_UINT32) const;
+          int operator> (ACE_UINT32) const;
+          int operator>= (ACE_UINT32) const;
+          //@}
         };
-#     endif /* ! ACE_BIG_ENDIAN	*/
 #   endif /* no	native 64 bit integer type */
 
 #   if defined (NONNATIVE_LONGLONG)
@@ -223,8 +246,8 @@ public:
       struct Float
       {
 #  	if ACE_SIZEOF_INT == 4
-	  // Use u_int to get word alignment.
-	  u_int	f;
+	  // Use unsigned int to get word alignment.
+	  unsigned int f;
 #  	else  /* ACE_SIZEOF_INT	!= 4 */
 	  // Applications will probably	have trouble with this.
 	  char f[4];
@@ -244,8 +267,8 @@ public:
       struct Double
       {
 #  	if ACE_SIZEOF_LONG == 8
-	  // Use u_long	to get word alignment.
-	  u_long f;
+	  // Use u long to get word alignment.
+	  unsigned long f;
 #  	else  /* ACE_SIZEOF_INT	!= 8 */
 	  // Applications will probably	have trouble with this.
 	  char f[8];
diff --git a/ace/CDR_Base.inl b/ace/CDR_Base.inl
index bf0f8b8d878..b74a075f733 100644
--- a/ace/CDR_Base.inl
+++ b/ace/CDR_Base.inl
@@ -149,15 +149,6 @@ ACE_CDR::swap_16 (const char* orig, char* target)
   swap_8 (orig, target + 8);
 }
 
-ACE_INLINE void
-ACE_CDR::mb_align (ACE_Message_Block *mb)
-{
-  char *start = ACE_ptr_align_binary (mb->base (),
-                                      ACE_CDR::MAX_ALIGNMENT);
-  mb->rd_ptr (start);
-  mb->wr_ptr (start);
-}
-
 ACE_INLINE size_t
 ACE_CDR::first_size (size_t minsize)
 {
@@ -203,3 +194,55 @@ ACE_CDR::next_size (size_t minsize)
 }
 
 // ****************************************************************
+
+#if defined (NONNATIVE_LONGLONG)
+ACE_INLINE
+ACE_CDR::LongLong::LongLong (ACE_INT32 l)
+{
+  *this = l;
+}
+
+ACE_INLINE
+ACE_CDR::LongLong::LongLong (ACE_UINT32 l)
+{
+  *this = l;
+}
+
+ACE_INLINE void
+ACE_CDR::LongLong::operator= (ACE_CDR::Long rhs)
+{
+  // Take into account the 2's complement when storing the signed 32
+  // bit integer.
+  if (rhs >= 0)
+    {
+      this->l = rhs;
+      this->h = 0;
+    }
+  else
+    {
+      this->l = rhs;
+      this->h = 0xFFFFFFFF;
+    }
+}
+
+ACE_INLINE void
+ACE_CDR::LongLong::operator= (ACE_CDR::ULong rhs)
+{
+  // When storing the unsigned long value be careful to prevent
+  // overflow.
+  if (rhs <= ACE_static_cast (ACE_CDR::ULong, ACE_INT32_MAX))
+    {
+      this->l = ACE_static_cast (ACE_CDR::Long, rhs);
+      this->h = 0;
+    }
+  else
+    {
+      // 2's complement since this structure represents a signed
+      // "long long" value.
+      this->l = 0;
+      this->h = rhs - ACE_INT32_MAX;
+    }
+}
+#endif  /* NONNATIVE_LONGLONG */
+
+// ****************************************************************
diff --git a/ace/CDR_Stream.h b/ace/CDR_Stream.h
index 8ef367055a6..0cb741a6d5c 100644
--- a/ace/CDR_Stream.h
+++ b/ace/CDR_Stream.h
@@ -44,6 +44,17 @@
 #include "ace/SString.h"
 #include "ace/Message_Block.h"
 
+
+// Stuff used by the ACE CDR classes.
+#if defined ACE_LITTLE_ENDIAN
+#  define ACE_CDR_BYTE_ORDER 1
+// little endian encapsulation byte order has value = 1
+#else  /* ! ACE_LITTLE_ENDIAN */
+#  define ACE_CDR_BYTE_ORDER 0
+// big endian encapsulation byte order has value = 0
+#endif /* ! ACE_LITTLE_ENDIAN */
+
+
 class ACE_Char_Codeset_Translator;
 class ACE_WChar_Codeset_Translator;
 
diff --git a/ace/Capabilities.cpp b/ace/Capabilities.cpp
index 9257178d486..9f5db74fc7d 100644
--- a/ace/Capabilities.cpp
+++ b/ace/Capabilities.cpp
@@ -1,6 +1,3 @@
-// $Id$
-
-#include "ace/Map_Manager.h"
 #include "ace/Capabilities.h"
 #include "ace/Log_Msg.h"
 
@@ -8,13 +5,21 @@
 #include "ace/Capabilities.i"
 #endif /* !__ACE_INLINE__ */
 
+
+ACE_RCSID (ace,
+           Capabilities,
+           "$Id$")
+
+
 #define ACE_ESC ((ACE_TCHAR)0x1b)
 
+
 ACE_CapEntry::~ACE_CapEntry (void)
 {
 }
 
 ACE_Capabilities::ACE_Capabilities (void)
+  : caps_ ()
 {
 }
 
@@ -94,17 +99,17 @@ ACE_Capabilities::parse (const ACE_TCHAR *buf, int &cap)
 void
 ACE_Capabilities::resetcaps (void)
 {
-  for (ACE_Hash_Map_Iterator<ACE_TString, ACE_CapEntry *, ACE_Null_Mutex> iter (caps_);
+  for (MAP::ITERATOR iter (this->caps_);
        !iter.done ();
        iter.advance ())
     {
-      ACE_Hash_Map_Entry<ACE_TString,ACE_CapEntry*> *entry;
+      MAP::ENTRY *entry;
       iter.next (entry);
       delete entry->int_id_;
     }
 
-  caps_.close ();
-  caps_.open ();
+  this->caps_.close ();
+  this->caps_.open ();
 }
 
 int
@@ -147,7 +152,7 @@ ACE_Capabilities::fillent (const ACE_TCHAR *buf)
           ACE_NEW_RETURN (ce,
                           ACE_StringCapEntry (s),
                           -1);
-          if (caps_.bind (name, ce) == -1)
+          if (this->caps_.bind (name, ce) == -1)
             {
               delete ce;
               return -1;
@@ -159,7 +164,7 @@ ACE_Capabilities::fillent (const ACE_TCHAR *buf)
           ACE_NEW_RETURN (ce,
                           ACE_IntCapEntry (n),
                           -1);
-          if (caps_.bind (name, ce) == -1)
+          if (this->caps_.bind (name, ce) == -1)
             {
               delete ce;
               return -1;
@@ -170,7 +175,7 @@ ACE_Capabilities::fillent (const ACE_TCHAR *buf)
           ACE_NEW_RETURN (ce,
                           ACE_BoolCapEntry (1),
                           -1);
-          if (caps_.bind (name, ce) == -1)
+          if (this->caps_.bind (name, ce) == -1)
             {
               delete ce;
               return -1;
@@ -242,7 +247,7 @@ int
 ACE_Capabilities::getval (const ACE_TCHAR *keyname, ACE_TString &val)
 {
   ACE_CapEntry* cap;
-  if (caps_.find (keyname, cap) == -1)
+  if (this->caps_.find (keyname, cap) == -1)
     return -1;
 
   ACE_StringCapEntry *scap =
@@ -258,7 +263,7 @@ int
 ACE_Capabilities::getval (const ACE_TCHAR *keyname, int &val)
 {
   ACE_CapEntry *cap;
-  if (caps_.find (keyname, cap) == -1)
+  if (this->caps_.find (keyname, cap) == -1)
     return -1;
 
   ACE_IntCapEntry *icap =
@@ -344,9 +349,6 @@ ACE_Capabilities::getent (const ACE_TCHAR *fname, const ACE_TCHAR *name)
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Hash_Map_Manager<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>;
 template class ACE_Hash_Map_Entry<ACE_TString,ACE_CapEntry*>;
 template class ACE_Hash_Map_Manager_Ex<ACE_TString,ACE_CapEntry*,ACE_Hash<ACE_TString>,ACE_Equal_To<ACE_TString>,ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Base_Ex<ACE_TString,ACE_CapEntry*,ACE_Hash<ACE_TString>,ACE_Equal_To<ACE_TString>,ACE_Null_Mutex>;
@@ -355,9 +357,6 @@ template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_TString,ACE_CapEntry*,ACE_Ha
 template class ACE_Hash<ACE_TString>;
 template class ACE_Equal_To<ACE_TString>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Hash_Map_Manager<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_TString,ACE_CapEntry*,ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Entry<ACE_TString,ACE_CapEntry*>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_TString,ACE_CapEntry*,ACE_Hash<ACE_TString>,ACE_Equal_To<ACE_TString>,ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ACE_TString,ACE_CapEntry*,ACE_Hash<ACE_TString>,ACE_Equal_To<ACE_TString>,ACE_Null_Mutex>
diff --git a/ace/Capabilities.h b/ace/Capabilities.h
index 4ddec4bb40f..550a2fb71c2 100644
--- a/ace/Capabilities.h
+++ b/ace/Capabilities.h
@@ -22,7 +22,7 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "ace/Synch.h"
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 #include "ace/Containers.h"
 #include "ace/SString.h"
 
@@ -33,15 +33,17 @@
  * subclasses.
  *
  * This class is not instantiable and does not provide accessors
- * or methods.  If you want to add a new kind of attribute you
- * subclasses of this class and dynamic cast to proper subclass.
+ * or methods.  If you want to add a new kind of attribute subclass
+ * this class and dynamic_cast to proper subclass.
  */
 class ACE_Export ACE_CapEntry
 {
 public:
+
    virtual ~ACE_CapEntry (void);
 
 protected:
+
   enum
   {
     ACE_INTCAP = 0,
@@ -51,7 +53,10 @@ protected:
 
   ACE_CapEntry (int captype);
 
+protected:
+
   int captype_;
+
 };
 
 /**
@@ -126,6 +131,9 @@ protected:
 class ACE_Export ACE_Capabilities
 {
 public:
+
+  typedef  ACE_Hash_Map_Manager_Ex<ACE_TString, ACE_CapEntry *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex> MAP;
+
   /// The Constructor
   ACE_Capabilities (void);
 
@@ -133,6 +141,7 @@ public:
   ~ACE_Capabilities(void);
 
 public:
+
   /// Get a string entry.
   int getval (const ACE_TCHAR *ent, ACE_TString &val);
 
@@ -144,6 +153,7 @@ public:
   int getent (const ACE_TCHAR *fname, const ACE_TCHAR *name);
 
 protected:
+
   /// Parse an integer property
   const ACE_TCHAR *parse (const ACE_TCHAR *buf, int &cap);
 
@@ -166,10 +176,11 @@ protected:
   /// Reset the set of capabilities
   void resetcaps (void);
 
-  /// Attributes
 private:
+
   /// This is the set of ACE_CapEntry.
-  ACE_Hash_Map_Manager<ACE_TString, ACE_CapEntry *, ACE_Null_Mutex> caps_;
+  MAP caps_;
+
 };
 
 #if defined (ACE_IS_SPLITTING)
diff --git a/ace/Capabilities.i b/ace/Capabilities.i
index d34d0e08862..ca168c0491a 100644
--- a/ace/Capabilities.i
+++ b/ace/Capabilities.i
@@ -1,4 +1,5 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
+//
 // $Id$
 
 ACE_INLINE
@@ -23,7 +24,7 @@ ACE_IntCapEntry::getval (void) const
 ACE_INLINE
 ACE_StringCapEntry::ACE_StringCapEntry (const ACE_TString &val)
   : ACE_CapEntry (ACE_STRINGCAP),
-    val_(val)
+    val_ (val)
 {
 }
 
diff --git a/ace/Configuration.cpp b/ace/Configuration.cpp
index 3b8e9a6164b..19b454d0a22 100644
--- a/ace/Configuration.cpp
+++ b/ace/Configuration.cpp
@@ -37,9 +37,6 @@ template class ACE_Hash<ACE_Configuration_ExtId>;
 template class ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, int, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager<ACE_Configuration_ExtId, int, ACE_Null_Mutex>;
 template class ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId>;
 template class ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId>;
 template class ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, int>;
@@ -73,9 +70,6 @@ template class ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, int>;
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId, int, ACE_Hash<ACE_Configuration_ExtId>, ACE_Equal_To<ACE_Configuration_ExtId>, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_Configuration_ExtId, int, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, ACE_Configuration_Section_IntId>
 #pragma instantiate ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId>
 #pragma instantiate ACE_Hash_Map_With_Allocator<ACE_Configuration_ExtId, int>
@@ -1621,7 +1615,7 @@ ACE_Configuration_Heap::remove_section (const ACE_Configuration_Section_Key& key
 
   section += sub_section;
   ACE_Configuration_ExtId SectionExtId (section.fast_rep ());
-  SECTION_ENTRY* section_entry;
+  SECTION_HASH::ENTRY* section_entry;
   SECTION_HASH* hashmap = index_;
   if (hashmap->find (SectionExtId, section_entry))
     return -1;
@@ -1652,7 +1646,7 @@ ACE_Configuration_Heap::remove_section (const ACE_Configuration_Section_Key& key
 
   // Now remove subkey from parent key
   ACE_Configuration_ExtId SubSExtId (sub_section);
-  SUBSECTION_ENTRY* subsection_entry;
+  SUBSECTION_HASH::ENTRY* subsection_entry;
   if (((SUBSECTION_HASH*)ParentIntId.section_hash_map_)->
       find (SubSExtId, subsection_entry))
     return -1;
@@ -1671,7 +1665,7 @@ ACE_Configuration_Heap::remove_section (const ACE_Configuration_Section_Key& key
   VALUE_HASH::ITERATOR value_iter = value_hash_map->begin ();
   while (!value_iter.done ())
     {
-      VALUE_ENTRY* value_entry;
+      VALUE_HASH::ENTRY* value_entry;
       if (!value_iter.next (value_entry))
         return 1;
 
@@ -1803,7 +1797,7 @@ ACE_Configuration_Heap::set_string_value (const ACE_Configuration_Section_Key& k
     return -1;
 
   // Get the entry for this item (if it exists)
-  VALUE_ENTRY* entry;
+  VALUE_HASH::ENTRY* entry;
   ACE_Configuration_ExtId item_name (name);
   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
     {
@@ -1861,7 +1855,7 @@ ACE_Configuration_Heap::set_integer_value (const ACE_Configuration_Section_Key&
     return -1;  // section does not exist
 
   // Get the entry for this item (if it exists)
-  VALUE_ENTRY* entry;
+  VALUE_HASH::ENTRY* entry;
   ACE_Configuration_ExtId item_name (name);
   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
     {
@@ -1910,7 +1904,7 @@ ACE_Configuration_Heap::set_binary_value (const ACE_Configuration_Section_Key& k
     return -1;    // section does not exist
 
   // Get the entry for this item (if it exists)
-  VALUE_ENTRY* entry;
+  VALUE_HASH::ENTRY* entry;
   ACE_Configuration_ExtId item_name (name);
   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
     {
@@ -2124,7 +2118,7 @@ ACE_Configuration_Heap::find_value (const ACE_Configuration_Section_Key& key,
 
   // Find it
   ACE_Configuration_ExtId ValueExtId (name);
-  VALUE_ENTRY* value_entry;
+  VALUE_HASH::ENTRY* value_entry;
   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
     return -1;  // value does not exist
 
@@ -2153,7 +2147,7 @@ ACE_Configuration_Heap::remove_value (const ACE_Configuration_Section_Key& key,
 
   // Find it
   ACE_Configuration_ExtId ValueExtId (name);
-  VALUE_ENTRY* value_entry;
+  VALUE_HASH::ENTRY* value_entry;
   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
     return -1;
 
diff --git a/ace/Configuration.h b/ace/Configuration.h
index 64b8e6ba28c..1932e84dcb5 100644
--- a/ace/Configuration.h
+++ b/ace/Configuration.h
@@ -601,8 +601,9 @@ typedef ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId,
                                 ACE_Equal_To<ACE_Configuration_ExtId>,
                                 ACE_Null_Mutex>
         SUBSECTION_HASH;
-typedef ACE_Hash_Map_Entry<ACE_Configuration_ExtId, int>
-        SUBSECTION_ENTRY;
+
+// Deprecated typedef.  Use the SUBSECTION_HASH::ENTRY trait instead.
+typedef SUBSECTION_HASH::ENTRY SUBSECTION_ENTRY;
 
 /**
  * @class ACE_Configuration_Value_IntId
@@ -662,9 +663,9 @@ typedef ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId,
                                 ACE_Equal_To<ACE_Configuration_ExtId>,
                                 ACE_Null_Mutex>
         VALUE_HASH;
-typedef ACE_Hash_Map_Entry<ACE_Configuration_ExtId,
-                           ACE_Configuration_Value_IntId>
-        VALUE_ENTRY;
+
+// Deprecated typedef.  Use the VALUE_HASH::ENTRY trait instead.
+typedef VALUE_HASH::ENTRY VALUE_ENTRY;
 
 /**
  * @class ACE_Configuration_Section_IntId
@@ -711,9 +712,9 @@ typedef ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId,
                                 ACE_Equal_To<ACE_Configuration_ExtId>,
                                 ACE_Null_Mutex>
         SECTION_HASH;
-typedef ACE_Hash_Map_Entry<ACE_Configuration_ExtId,
-                           ACE_Configuration_Section_IntId>
-        SECTION_ENTRY;
+
+// Deprecated typedef.  Use the SECTION_HASH::ENTRY trait instead.
+typedef SECTION_HASH::ENTRY SECTION_ENTRY;
 
 /**
  * @class ACE_Configuration_Section_Key_Heap
diff --git a/ace/Connector.cpp b/ace/Connector.cpp
index 511db1e662b..2e00fac20c7 100644
--- a/ace/Connector.cpp
+++ b/ace/Connector.cpp
@@ -1,16 +1,16 @@
-// Connector.cpp
-// $Id$
-
-#ifndef ACE_CONNECTOR_C
-#define ACE_CONNECTOR_C
+#ifndef ACE_CONNECTOR_CPP
+#define ACE_CONNECTOR_CPP
 
 #include "ace/Connector.h"
+#include "ace/Svc_Handler.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-ACE_RCSID(ace, Connector, "$Id$")
+ACE_RCSID (ace,
+           Connector,
+           "$Id$")
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Connector)
 
diff --git a/ace/Connector.h b/ace/Connector.h
index 2c938c8a2a5..8fd528e383a 100644
--- a/ace/Connector.h
+++ b/ace/Connector.h
@@ -15,16 +15,16 @@
 
 #include "ace/pre.h"
 
-#include "ace/Service_Config.h"
+#include "ace/Service_Object.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/Service_Object.h"
 #include "ace/Map_Manager.h"
-#include "ace/Svc_Handler.h"
 #include "ace/Strategies_T.h"
+#include "ace/Synch_Options.h"
+
 
 /**
  * @class ACE_Svc_Tuple
diff --git a/ace/Copy_Disabled.h b/ace/Copy_Disabled.h
index 4fca4e2b3e4..d408c013b86 100644
--- a/ace/Copy_Disabled.h
+++ b/ace/Copy_Disabled.h
@@ -57,4 +57,4 @@ private:
 
 #include "ace/post.h"
 
-#endif /* ACE_FUNCTOR_H */
+#endif /* ACE_COPY_DISABLED_H */
diff --git a/ace/Default_Constants.h b/ace/Default_Constants.h
index 4bfc3ecdadb..37f35c34fba 100644
--- a/ace/Default_Constants.h
+++ b/ace/Default_Constants.h
@@ -345,8 +345,41 @@
 // Max size of an ACE Token client ID.
 # define ACE_MAXCLIENTIDLEN MAXHOSTNAMELEN + 20
 
-
-
+/**
+ * @name Default values to control CDR classes memory allocation strategies
+ */
+//@{
+
+/// Control the initial size of all CDR buffers, application
+/// developers may want to optimize this value to fit their request
+/// size
+#if !defined (ACE_DEFAULT_CDR_BUFSIZE)
+#  define ACE_DEFAULT_CDR_BUFSIZE 512
+#endif /* ACE_DEFAULT_CDR_BUFSIZE */
+
+/// Stop exponential growth of CDR buffers to avoid overallocation
+#if !defined (ACE_DEFAULT_CDR_EXP_GROWTH_MAX)
+#  define ACE_DEFAULT_CDR_EXP_GROWTH_MAX 65536
+#endif /* ACE_DEFAULT_CDR_EXP_GROWTH_MAX */
+
+/// Control CDR buffer growth after maximum exponential growth is
+/// reached
+#if !defined (ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK)
+#  define ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK 65536
+#endif /* ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK */
+//@}
+
+/// Control the zero-copy optimizations for octet sequences
+/**
+ * Large octet sequences can be sent without any copies by chaining
+ * them in the list of message blocks that represent a single CDR
+ * stream.  However, if the octet sequence is too small the zero copy
+ * optimizations actually hurt performance.  Octet sequences smaller
+ * than this value will be copied.
+ */
+#if !defined (ACE_DEFAULT_CDR_MEMCPY_TRADEOFF)
+#define ACE_DEFAULT_CDR_MEMCPY_TRADEOFF 256
+#endif /* ACE_DEFAULT_CDR_MEMCPY_TRADEOFF */
 
 
 #include "ace/post.h"
diff --git a/ace/Dynamic_Service_Base.cpp b/ace/Dynamic_Service_Base.cpp
index 6bcc87ad1ec..ab4b1bc5a62 100644
--- a/ace/Dynamic_Service_Base.cpp
+++ b/ace/Dynamic_Service_Base.cpp
@@ -1,11 +1,14 @@
-// $Id$
-
 #include "ace/Dynamic_Service_Base.h"
 #include "ace/Service_Config.h"
 #include "ace/Service_Repository.h"
+#include "ace/Service_Types.h"
 #include "ace/Log_Msg.h"
 
-ACE_RCSID(ace, Dynamic_Service_Base, "$Id$")
+
+ACE_RCSID (ace,
+           Dynamic_Service_Base,
+           "$Id$")
+
 
 void
 ACE_Dynamic_Service_Base::dump (void) const
diff --git a/ace/Filecache.cpp b/ace/Filecache.cpp
index 8f1311823e9..cd41b9f8e46 100644
--- a/ace/Filecache.cpp
+++ b/ace/Filecache.cpp
@@ -136,7 +136,7 @@ ACE_Filecache_Handle::size (void) const
 #if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
 
 #define ACE_Filecache_Hash \
-        ACE_Hash_Map_Manager<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>
+        ACE_Hash_Map_Manager_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 #define ACE_Filecache_Hash_Entry \
         ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *>
 
@@ -741,18 +741,12 @@ ACE_Filecache_Object::update (void) const
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 #if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
 template class ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *>;
-template class ACE_Hash_Map_Manager<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Base_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Reverse_Iterator_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>;
 #else
 template class ACE_Hash_Map_Entry<ACE_TString, ACE_Filecache_Object *>;
-template class ACE_Hash_Map_Manager<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Base_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
@@ -761,18 +755,12 @@ template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_TString, ACE_Filecache_Objec
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
 #pragma instantiate ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *>
-#pragma instantiate ACE_Hash_Map_Manager<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
 #else
 #pragma instantiate ACE_Hash_Map_Entry<ACE_TString, ACE_Filecache_Object *>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>
diff --git a/ace/Filecache.h b/ace/Filecache.h
index 78bedd38a64..0bcd8264b79 100644
--- a/ace/Filecache.h
+++ b/ace/Filecache.h
@@ -1,4 +1,4 @@
-/* -*- c++ -*- */
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -13,6 +13,7 @@
 
 #ifndef ACE_FILECACHE_H
 #define ACE_FILECACHE_H
+
 #include "ace/pre.h"
 
 #include "ace/Mem_Map.h"
@@ -22,7 +23,7 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "ace/Synch_T.h"
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 #include "ace/SString.h"
 
 enum ACE_Filecache_Flag
@@ -145,19 +146,22 @@ private:
 };
 
 #if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
-typedef ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *>
-        ACE_Filecache_Hash_Entry;
 
-typedef ACE_Hash_Map_Manager<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Null_Mutex>
+typedef ACE_Hash_Map_Manager_Ex<const ACE_TCHAR *, ACE_Filecache_Object *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>
         ACE_Filecache_Hash;
+
+typedef ACE_Hash_Map_Entry<const ACE_TCHAR *, ACE_Filecache_Object *> ACE_Filecache_Hash_Entry;
+
 #else
-typedef ACE_Hash_Map_Entry<ACE_TString, ACE_Filecache_Object *>
-        ACE_Filecache_Hash_Entry;
 
-typedef ACE_Hash_Map_Manager<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>
+typedef ACE_Hash_Map_Manager_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>
         ACE_Filecache_Hash;
+
+typedef ACE_Filecache_Hash::ENTRY ACE_Filecache_Hash_Entry;
+
 #endif /* ACE_HAS_TEMPLATE_SPECIALIZATION */
 
+
 /**
  * @class ACE_Filecache
  *
@@ -352,4 +356,5 @@ private:
 
 
 #include "ace/post.h"
+
 #endif /* ACE_FILECACHE_H */
diff --git a/ace/Future_Set.h b/ace/Future_Set.h
index d440b88efae..14ad83245bd 100644
--- a/ace/Future_Set.h
+++ b/ace/Future_Set.h
@@ -17,7 +17,7 @@
 #include "ace/Thread.h"
 #include "ace/Message_Queue.h"
 #include "ace/Future.h"
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 #pragma once
diff --git a/ace/Hash_Map_Manager_T.i b/ace/Hash_Map_Manager_T.i
index e3b8372440b..6c6dc935db8 100644
--- a/ace/Hash_Map_Manager_T.i
+++ b/ace/Hash_Map_Manager_T.i
@@ -582,7 +582,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::oper
   ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (int)");
 
   ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -603,7 +603,7 @@ ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::oper
   ACE_TRACE ("ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (int)");
 
   ACE_Hash_Map_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -652,7 +652,7 @@ ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>
   ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (int)");
 
   ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -673,7 +673,7 @@ ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>
   ACE_TRACE ("ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (int)");
 
   ACE_Hash_Map_Const_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -709,7 +709,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::
   ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (int)");
 
   ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -730,7 +730,7 @@ ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::
   ACE_TRACE ("ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (int)");
 
   ACE_Hash_Map_Bucket_Iterator<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -830,7 +830,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC
   ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator++ (int)");
 
   ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  ++*this;
   return retv;
 }
 
@@ -851,7 +851,7 @@ ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOC
   ACE_TRACE ("ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::operator-- (int)");
 
   ACE_Hash_Map_Reverse_Iterator_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  --*this;
   return retv;
 }
 
diff --git a/ace/Hash_Map_With_Allocator_T.cpp b/ace/Hash_Map_With_Allocator_T.cpp
index fa2a44ca06d..644dfe50e06 100644
--- a/ace/Hash_Map_With_Allocator_T.cpp
+++ b/ace/Hash_Map_With_Allocator_T.cpp
@@ -16,7 +16,7 @@
 
 template <class EXT_ID, class INT_ID>
 ACE_Hash_Map_With_Allocator<EXT_ID, INT_ID>::ACE_Hash_Map_With_Allocator (ACE_Allocator *alloc)
-  : ACE_Hash_Map_Manager<EXT_ID, INT_ID, ACE_Null_Mutex> (alloc)
+  : ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, ACE_Hash<EXT_ID>, ACE_Equal_To<EXT_ID>, ACE_Null_Mutex> (alloc)
 {
   ACE_TRACE ("ACE_Hash_Map_With_Allocator<EXT_ID, INT_ID>::ACE_Hash_Map_With_Allocator");
 }
@@ -24,7 +24,7 @@ ACE_Hash_Map_With_Allocator<EXT_ID, INT_ID>::ACE_Hash_Map_With_Allocator (ACE_Al
 template <class EXT_ID, class INT_ID>
 ACE_Hash_Map_With_Allocator<EXT_ID, INT_ID>::ACE_Hash_Map_With_Allocator (size_t size,
                                                                           ACE_Allocator *alloc)
-  : ACE_Hash_Map_Manager<EXT_ID, INT_ID, ACE_Null_Mutex> (size, alloc)
+  : ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, ACE_Hash<EXT_ID>, ACE_Equal_To<EXT_ID>, ACE_Null_Mutex> (size, alloc)
 {
   ACE_TRACE ("ACE_Hash_Map_With_Allocator<EXT_ID, INT_ID>::ACE_Hash_Map_With_Allocator");
 }
diff --git a/ace/Hash_Map_With_Allocator_T.h b/ace/Hash_Map_With_Allocator_T.h
index 6ee18da8a22..84721bb8d68 100644
--- a/ace/Hash_Map_With_Allocator_T.h
+++ b/ace/Hash_Map_With_Allocator_T.h
@@ -14,7 +14,7 @@
 #define ACE_HASH_MAP_WITH_ALLOCATOR_T_H
 #include "ace/pre.h"
 
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 #include "ace/Synch.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
@@ -42,7 +42,7 @@
  */
 template <class EXT_ID, class INT_ID>
 class ACE_Hash_Map_With_Allocator :
-  public ACE_Hash_Map_Manager<EXT_ID, INT_ID, ACE_Null_Mutex>
+  public ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, ACE_Hash<EXT_ID>, ACE_Equal_To<EXT_ID>, ACE_Null_Mutex>
 {
 public:
   /// Constructor.
diff --git a/ace/Local_Name_Space.cpp b/ace/Local_Name_Space.cpp
index 60f0cd5e817..958cc01b9dd 100644
--- a/ace/Local_Name_Space.cpp
+++ b/ace/Local_Name_Space.cpp
@@ -169,9 +169,6 @@ ACE_NS_Internal::type (void)
 template class ACE_Hash_Map_Entry<ACE_NS_String, ACE_NS_Internal>;
 template class ACE_Hash<ACE_NS_String>;
 template class ACE_Equal_To<ACE_NS_String>;
-template class ACE_Hash_Map_Manager<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
@@ -197,9 +194,6 @@ template class ACE_Write_Guard<ACE_RW_Process_Mutex>;
 #pragma instantiate ACE_Hash_Map_Entry<ACE_NS_String, ACE_NS_Internal>
 #pragma instantiate ACE_Hash<ACE_NS_String>
 #pragma instantiate ACE_Equal_To<ACE_NS_String>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>
 #pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>
diff --git a/ace/Local_Name_Space_T.cpp b/ace/Local_Name_Space_T.cpp
index 56dbf42f516..d64e9f38665 100644
--- a/ace/Local_Name_Space_T.cpp
+++ b/ace/Local_Name_Space_T.cpp
@@ -1,10 +1,7 @@
-// $Id$
-
 #ifndef ACE_LOCAL_NAME_SPACE_T_C
 #define ACE_LOCAL_NAME_SPACE_T_C
 
 #include "ace/ACE.h"
-#include "ace/Auto_Ptr.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -12,7 +9,11 @@
 
 #include "ace/Local_Name_Space.h"
 
-ACE_RCSID(ace, Local_Name_Space_T, "$Id$")
+
+ACE_RCSID (ace,
+           Local_Name_Space_T,
+           "$Id$")
+
 
 template <class ALLOCATOR>
 ACE_Name_Space_Map<ALLOCATOR>::ACE_Name_Space_Map (ALLOCATOR *alloc)
@@ -105,10 +106,11 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::remap (EXCEPTION_POINTERS *ep)
 #endif /* ACE_WIN32 */
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (const ACE_NS_WString &name,
-                                                             const ACE_NS_WString &value,
-                                                             const char *type,
-                                                             int rebind)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (
+  const ACE_NS_WString &name,
+  const ACE_NS_WString &value,
+  const char *type,
+  int rebind)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -125,10 +127,11 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (const ACE_NS_WStrin
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (const ACE_NS_WString &name,
-                                                               const ACE_NS_WString &value,
-                                                               const char *type,
-                                                               int rebind)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (
+  const ACE_NS_WString &name,
+  const ACE_NS_WString &value,
+  const char *type,
+  int rebind)
 {
 
   ACE_TRACE ("ACE_Local_Name_Space::shared_bind_i");
@@ -161,19 +164,23 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (const ACE_NS_WStr
         {
           // Do a normal bind.  This will fail if there's already an
           // <new_internal> with the same name.
-          result = this->name_space_map_->bind (new_name, new_internal, this->allocator_);
+          result = this->name_space_map_->bind (new_name,
+                                                new_internal,
+                                                this->allocator_);
 
           if (result == 1)
             {
-              // Entry already existed so bind failed. Free our dynamically allocated memory.
+              // Entry already existed so bind failed. Free our
+              // dynamically allocated memory.
               this->allocator_->free ((void *) ptr);
               return result;
             }
         }
       else
         {
-          // Do a rebind.  If there's already any entry, this will return the existing
-          // <new_name> and <new_internal> and overwrite the existing name binding.
+          // Do a rebind.  If there's already any entry, this will
+          // return the existing <new_name> and <new_internal> and
+          // overwrite the existing name binding.
           ACE_NS_String old_name;
           ACE_NS_Internal old_internal;
 
@@ -182,9 +189,10 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (const ACE_NS_WStr
                                                   this->allocator_);
           if (result == 1)
             {
-              // Free up the memory we allocated in shared_bind().  Note that this
-              // assumes that the "value" pointer comes first and that the value,
-              // name, and type are contiguously allocated (see above for details)
+              // Free up the memory we allocated in shared_bind().
+              // Note that this assumes that the "value" pointer comes
+              // first and that the value, name, and type are
+              // contiguously allocated (see above for details)
               this->allocator_->free ((void *) (old_internal.value ()).fast_rep ());
             }
         }
@@ -203,7 +211,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (const ACE_NS_WStr
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const ACE_NS_WString &name)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind (
+  const ACE_NS_WString &name)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -221,7 +230,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const ACE_NS_WString &na
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind_i (const ACE_NS_WString &name)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind_i (
+  const ACE_NS_WString &name)
 {
   ACE_TRACE ("ACE_Local_Name_Space::unbind_i");
 
@@ -242,9 +252,10 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind_i (const ACE_NS_WString &
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::bind (const ACE_NS_WString &name,
-                                                      const ACE_NS_WString &value,
-                                                      const char *type)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::bind (
+  const ACE_NS_WString &name,
+  const ACE_NS_WString &value,
+  const char *type)
 {
   ACE_TRACE ("ACE_Local_Name_Space::bind");
   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
@@ -253,9 +264,10 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::bind (const ACE_NS_WString &name
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::rebind (const ACE_NS_WString &name,
-                                                        const ACE_NS_WString &value,
-                                                        const char *type)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::rebind (
+  const ACE_NS_WString &name,
+  const ACE_NS_WString &value,
+  const char *type)
 {
   ACE_TRACE ("ACE_Local_Name_Space::rebind");
   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
@@ -264,9 +276,10 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::rebind (const ACE_NS_WString &na
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve (const ACE_NS_WString &name,
-                                                         ACE_NS_WString &value,
-                                                         char *&type)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve (
+  const ACE_NS_WString &name,
+  ACE_NS_WString &value,
+  char *&type)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -284,9 +297,10 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve (const ACE_NS_WString &n
 
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve_i (const ACE_NS_WString &name,
-                                                           ACE_NS_WString &value,
-                                                           char *&type)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve_i (
+  const ACE_NS_WString &name,
+  ACE_NS_WString &value,
+  char *&type)
 {
   ACE_TRACE ("ACE_Local_Name_Space::resolve_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
@@ -324,7 +338,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve_i (const ACE_NS_WString
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::open (ACE_Naming_Context::Context_Scope_Type scope_in)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::open (
+  ACE_Naming_Context::Context_Scope_Type scope_in)
 {
   ACE_TRACE ("ACE_Local_Name_Space::open");
   this->ns_scope_ = scope_in;
@@ -342,8 +357,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Local_Name_Space (void)
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK>
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Local_Name_Space (ACE_Naming_Context::Context_Scope_Type scope_in,
-                                                                      ACE_Name_Options *name_options)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Local_Name_Space (
+  ACE_Naming_Context::Context_Scope_Type scope_in,
+  ACE_Name_Options *name_options)
   : name_options_ (name_options)
 {
   ACE_TRACE ("ACE_Local_Name_Space::ACE_Local_Name_Space");
@@ -477,7 +493,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager_i (void)
     {
       this->name_space_map_ = (ACE_Name_Space_Map <ALLOCATOR> *) ns_map;
       if (ACE::debug ())
-        ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
                     this->name_space_map_, ns_map));
     }
 
@@ -493,7 +510,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager_i (void)
         {
           this->name_space_map_ = (ACE_Name_Space_Map <ALLOCATOR> *) ns_map;
           if (ACE::debug ())
-            ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
+            ACE_DEBUG ((LM_DEBUG,
+                        ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
                         this->name_space_map_, ns_map));
         }
       else
@@ -511,7 +529,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager_i (void)
         }
 
       if (ACE::debug ())
-        ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_LIB_TEXT ("name_space_map_ = %d, ns_map = %d\n"),
                     this->name_space_map_, ns_map));
     }
 
@@ -519,14 +538,15 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager_i (void)
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names_i (ACE_WSTRING_SET &set,
-                                                              const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names_i (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_names_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   int result = 1;
 
@@ -552,14 +572,15 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names_i (ACE_WSTRING_SET &s
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values_i (ACE_WSTRING_SET &set,
-                                                           const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values_i (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_values_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   int result = 1;
 
@@ -585,14 +606,15 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values_i (ACE_WSTRING_SET &
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types_i (ACE_WSTRING_SET &set,
-                                                          const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types_i (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_types_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   char *compiled_regexp = 0;
 
@@ -655,14 +677,15 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types_i (ACE_WSTRING_SET &s
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries_i (ACE_BINDING_SET &set,
-                                                                      const ACE_NS_WString &pattern)
+ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries_i (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_name_entries_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   for (map_entry = 0;
        map_iterator.next (map_entry) != 0;
@@ -683,14 +706,15 @@ ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries_i (ACE_BINDIN
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries_i (ACE_BINDING_SET &set,
-                                                                  const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries_i (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_value_entries_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   for (map_entry = 0;
        map_iterator.next (map_entry) != 0;
@@ -710,14 +734,15 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries_i (ACE_BINDIN
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries_i (ACE_BINDING_SET &set,
-                                                                 const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries_i (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   ACE_TRACE ("ACE_Local_Name_Space::list_type_entries_i");
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   char *compiled_regexp = 0;
   // Note that char_rep() allocates memory so we need to delete it
@@ -727,10 +752,12 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries_i (ACE_BINDING
   if (ACE_OS::strcmp ("", pattern_rep) == 0)
     compiled_regexp = ACE_OS::strdup ("");
   else
-    // Compile the regular expression (the 0's cause ACE_OS::compile to allocate space).
+    // Compile the regular expression (the 0's cause ACE_OS::compile
+    // to allocate space).
 #if defined (ACE_HAS_REGEX)
     compiled_regexp = ACE_OS::compile (pattern_rep, 0, 0);
-#else /* If we don't have regular expressions just the pattern directly. */
+#else /* If we don't have regular expressions just the pattern
+         directly. */
   compiled_regexp = pattern_rep;
 #endif /* ACE_HAS_REGEX */
 
@@ -741,10 +768,12 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries_i (ACE_BINDING
       // Get the type.
       const char *type = map_entry->int_id_.type ();
 
-      if (ACE_OS::strcmp ("", pattern_rep) == 0 // Everything matches the wildcard.
+      if (ACE_OS::strcmp ("", pattern_rep) == 0 // Everything matches
+                                                // the wildcard.
 #if defined (ACE_HAS_REGEX)
           || ACE_OS::step (type, compiled_regexp) != 0)
-#else /* If we don't have regular expressions just use strstr() for substring matching. */
+#else /* If we don't have regular expressions just use strstr() for
+         substring matching. */
         || ACE_OS::strstr (type, compiled_regexp) != 0)
 #endif /* ACE_HAS_REGEX */
         {
@@ -771,8 +800,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::dump_i (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 
-  MAP_ITERATOR map_iterator (*this->name_space_map_);
-  MAP_ENTRY *map_entry;
+  MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
+  MAP_MANAGER::ENTRY *map_entry;
 
   for (map_entry = 0;
        map_iterator.next (map_entry) != 0;
@@ -786,7 +815,8 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::dump_i (void) const
 
       ACE_DEBUG ((LM_DEBUG,  ACE_LIB_TEXT ("key=%s\nvalue=%s\ntype=%s\n"),
                   key, value, type));
-      // We need to delete key and value since char_rep allocates memory for them
+      // We need to delete key and value since char_rep allocates
+      // memory for them
       delete [] key;
       delete [] value;
     }
@@ -795,8 +825,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::dump_i (void) const
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names (ACE_WSTRING_SET &set,
-                                                        const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -813,8 +844,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names (ACE_WSTRING_SET &set
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values (ACE_WSTRING_SET &set,
-                                                             const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -831,8 +863,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values (ACE_WSTRING_SET &se
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types (ACE_WSTRING_SET &set,
-                                                            const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types (
+  ACE_WSTRING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -849,8 +882,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types (ACE_WSTRING_SET &set
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries (ACE_BINDING_SET &set,
-                                                                    const ACE_NS_WString &pattern)
+ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -867,8 +901,9 @@ ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries (ACE_BINDING_
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries (ACE_BINDING_SET &set,
-                                                                    const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
@@ -885,8 +920,9 @@ ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries (ACE_BINDING_
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries (ACE_BINDING_SET &set,
-                                                                   const ACE_NS_WString &pattern)
+ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries (
+  ACE_BINDING_SET &set,
+  const ACE_NS_WString &pattern)
 {
   // Note that we *must* use structured exception handling here
   // because (1) we may need to commit virtual memory pages and (2)
diff --git a/ace/Local_Name_Space_T.h b/ace/Local_Name_Space_T.h
index 1933908f2e6..0df51250b73 100644
--- a/ace/Local_Name_Space_T.h
+++ b/ace/Local_Name_Space_T.h
@@ -1,4 +1,4 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -32,17 +32,18 @@ typedef ACE_Unbounded_Set<ACE_NS_WString> ACE_WSTRING_SET;
 
 // Simplify later usage by defining typedefs.
 #if (1)
-#include "ace/Hash_Map_Manager.h"
-typedef ACE_Hash_Map_Manager<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex> MAP_MANAGER;
-typedef ACE_Hash_Map_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex> MAP_ITERATOR;
-typedef ACE_Hash_Map_Entry <ACE_NS_String, ACE_NS_Internal> MAP_ENTRY;
+# include "ace/Hash_Map_Manager_T.h"
+typedef ACE_Hash_Map_Manager_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex> MAP_MANAGER;
 #else
-#include "ace/Map_Manager.h"
+# include "ace/Map_Manager.h"
 typedef ACE_Map_Manager<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex> MAP_MANAGER;
-typedef ACE_Map_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex> MAP_ITERATOR;
-typedef ACE_Map_Entry <ACE_NS_String, ACE_NS_Internal> MAP_ENTRY;
 #endif /* 0 */
 
+// Deprecated typedefs.  Use the map's traits instead.
+typedef MAP_MANAGER::ITERATOR MAP_ITERATOR;
+typedef MAP_MANAGER::ENTRY MAP_ENTRY;
+
+
 /**
  * @class ACE_Name_Space_Map
  *
diff --git a/ace/Map_Manager.i b/ace/Map_Manager.i
index 0efe209c8eb..ba2a672b2e8 100644
--- a/ace/Map_Manager.i
+++ b/ace/Map_Manager.i
@@ -535,7 +535,7 @@ ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 {
   ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -552,7 +552,7 @@ ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 {
   ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -613,7 +613,7 @@ ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 {
   ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -630,7 +630,7 @@ ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 {
   ACE_Map_Const_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -691,7 +691,7 @@ ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator++ (int)
 {
   ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  ++*this;
   return retv;
 }
 
@@ -708,6 +708,6 @@ ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>
 ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>::operator-- (int)
 {
   ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  --*this;
   return retv;
 }
diff --git a/ace/Map_T.h b/ace/Map_T.h
index 7730d9686d7..585cbc91ff8 100644
--- a/ace/Map_T.h
+++ b/ace/Map_T.h
@@ -16,7 +16,7 @@
 
 #include "ace/Pair_T.h"
 #include "ace/Map_Manager.h"
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 #include "ace/Active_Map_Manager.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
diff --git a/ace/OS.h b/ace/OS.h
index b4f40edd07d..8670316cdba 100644
--- a/ace/OS.h
+++ b/ace/OS.h
@@ -7064,51 +7064,6 @@ typedef ACE_TRANSMIT_FILE_BUFFERS* ACE_LPTRANSMIT_FILE_BUFFERS;
 #   define WCOREDUMP(stat) 0
 #endif /* WCOREDUMP */
 
-// Stuff used by the ACE CDR classes.
-#if defined ACE_LITTLE_ENDIAN
-#  define ACE_CDR_BYTE_ORDER 1
-// little endian encapsulation byte order has value = 1
-#else  /* ! ACE_LITTLE_ENDIAN */
-#  define ACE_CDR_BYTE_ORDER 0
-// big endian encapsulation byte order has value = 0
-#endif /* ! ACE_LITTLE_ENDIAN */
-
-/**
- * @name Default values to control CDR classes memory allocation strategies
- */
-//@{
-
-/// Control the initial size of all CDR buffers, application
-/// developers may want to optimize this value to fit their request
-/// size
-#if !defined (ACE_DEFAULT_CDR_BUFSIZE)
-#  define ACE_DEFAULT_CDR_BUFSIZE 512
-#endif /* ACE_DEFAULT_CDR_BUFSIZE */
-
-/// Stop exponential growth of CDR buffers to avoid overallocation
-#if !defined (ACE_DEFAULT_CDR_EXP_GROWTH_MAX)
-#  define ACE_DEFAULT_CDR_EXP_GROWTH_MAX 65536
-#endif /* ACE_DEFAULT_CDR_EXP_GROWTH_MAX */
-
-/// Control CDR buffer growth after maximum exponential growth is
-/// reached
-#if !defined (ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK)
-#  define ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK 65536
-#endif /* ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK */
-//@}
-
-/// Control the zero-copy optimizations for octet sequences
-/**
- * Large octet sequences can be sent without any copies by chaining
- * them in the list of message blocks that represent a single CDR
- * stream.  However, if the octet sequence is too small the zero copy
- * optimizations actually hurt performance.  Octet sequences smaller
- * than this value will be copied.
- */
-#if !defined (ACE_DEFAULT_CDR_MEMCPY_TRADEOFF)
-#define ACE_DEFAULT_CDR_MEMCPY_TRADEOFF 256
-#endif /* ACE_DEFAULT_CDR_MEMCPY_TRADEOFF */
-
 /**
  * In some environments it is useful to swap the bytes on write, for
  * instance: a fast server can be feeding a lot of slow clients that
diff --git a/ace/POSIX_Asynch_IO.cpp b/ace/POSIX_Asynch_IO.cpp
index 1cdc230d1f7..d1d153e5baa 100644
--- a/ace/POSIX_Asynch_IO.cpp
+++ b/ace/POSIX_Asynch_IO.cpp
@@ -1,6 +1,3 @@
-/* -*- C++ -*- */
-// $Id$
-
 #include "ace/POSIX_Asynch_IO.h"
 
 #if defined (ACE_HAS_AIO_CALLS)
@@ -15,6 +12,12 @@
 #include "ace/POSIX_Asynch_IO.i"
 #endif /* __ACE_INLINE__ */
 
+
+ACE_RCSID (ace,
+           POSIX_Asynch_IO,
+           "$Id$")
+
+
 size_t
 ACE_POSIX_Asynch_Result::bytes_transferred (void) const
 {
@@ -1580,8 +1583,8 @@ ACE_POSIX_Asynch_Connect::cancel_uncompleted (int flg_notify,
 
   int retval = 0;
 
-  MAP_ITERATOR  iter (result_map_);
-  MAP_ENTRY *   me = 0;
+  MAP_MANAGER::ITERATOR  iter (result_map_);
+  MAP_MANAGER::ENTRY *   me = 0;
 
   set.reset ();
 
diff --git a/ace/POSIX_Asynch_IO.h b/ace/POSIX_Asynch_IO.h
index 20e3ad6dd66..d3aab26cf71 100644
--- a/ace/POSIX_Asynch_IO.h
+++ b/ace/POSIX_Asynch_IO.h
@@ -902,10 +902,10 @@ private:
 
   typedef ACE_Map_Manager<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
           MAP_MANAGER;
-  typedef ACE_Map_Iterator<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
-          MAP_ITERATOR;
-  typedef ACE_Map_Entry<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *>
-          MAP_ENTRY;
+
+  // (Two) Deprecated typedefs.  Use the map traits instead.
+  typedef MAP_MANAGER::ITERATOR MAP_ITERATOR;
+  typedef MAP_MANAGER::ENTRY MAP_ENTRY;
 
   /// Map of Result pointers that correspond to all the <accept>'s
   /// pending.
diff --git a/ace/Parse_Node.cpp b/ace/Parse_Node.cpp
index 6605c728e80..98d52adbf12 100644
--- a/ace/Parse_Node.cpp
+++ b/ace/Parse_Node.cpp
@@ -4,6 +4,7 @@
 
 #include "ace/Service_Config.h"
 #include "ace/Service_Repository.h"
+#include "ace/Service_Types.h"
 #include "ace/Task.h"
 
 #if !defined (__ACE_INLINE__)
diff --git a/ace/Parse_Node.h b/ace/Parse_Node.h
index fced2c25241..fea5c7f6cbd 100644
--- a/ace/Parse_Node.h
+++ b/ace/Parse_Node.h
@@ -16,7 +16,7 @@
 
 #include "ace/pre.h"
 
-#include "ace/DLL.h"
+#include "ace/config-all.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -24,13 +24,12 @@
 
 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
 
-#include "ace/Service_Types.h"
-
+#include "ace/DLL.h"
 
 
 /// Forward declarations.
 class ACE_Service_Config;
-
+class ACE_Service_Type;
 
 /**
  * @class ACE_Parse_Node
diff --git a/ace/RB_Tree.i b/ace/RB_Tree.i
index 55deff16026..ed0a93fbb7e 100644
--- a/ace/RB_Tree.i
+++ b/ace/RB_Tree.i
@@ -891,7 +891,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator++ (int)
   ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator++ (int)");
 
   ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  ++*this;
   return retv;
 }
 
@@ -918,7 +918,7 @@ ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator-- (int)
   ACE_TRACE ("ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> operator-- (int)");
 
   ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  --*this;
   return retv;
 }
 
@@ -1094,7 +1094,7 @@ 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++ (int)");
 
   ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->reverse_i ();
+  ++*this;
   return retv;
 }
 
@@ -1121,7 +1121,7 @@ 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-- (int)");
 
   ACE_RB_Tree_Reverse_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> retv (*this);
-  this->forward_i ();
+  --*this;
   return retv;
 }
 
diff --git a/ace/SSL/SSL_SOCK_Acceptor.h b/ace/SSL/SSL_SOCK_Acceptor.h
index 12262c57355..d220c88bb83 100644
--- a/ace/SSL/SSL_SOCK_Acceptor.h
+++ b/ace/SSL/SSL_SOCK_Acceptor.h
@@ -47,7 +47,7 @@
  *       SSL implementations, such as OpenSSL, are not entirely
  *       thread-safe or reentrant.
  */
-class ACE_SSL_Export ACE_SSL_SOCK_Acceptor : public ACE_SSL_SOCK
+class ACE_SSL_Export ACE_SSL_SOCK_Acceptor : private ACE_SSL_SOCK
 {
 public:
 
diff --git a/ace/SSL/SSL_SOCK_Connector.cpp b/ace/SSL/SSL_SOCK_Connector.cpp
index d7de02c7cbb..3c5caff9c05 100644
--- a/ace/SSL/SSL_SOCK_Connector.cpp
+++ b/ace/SSL/SSL_SOCK_Connector.cpp
@@ -63,6 +63,9 @@ ACE_SSL_SOCK_Connector::ssl_connect (ACE_SSL_SOCK_Stream &new_stream,
             return -1;
     }
 
+  // Take into account the time between each select() call below.
+  ACE_Countdown_Time countdown (timeout);
+
   int status;
   do
     {
@@ -139,6 +142,9 @@ ACE_SSL_SOCK_Connector::ssl_connect (ACE_SSL_SOCK_Stream &new_stream,
                                 &wr_handle,
                                 0,
                                 timeout);
+
+          (void) countdown.update ();
+
           // 0 is timeout, so we're done.
           // -1 is error, so we're done.
           // Could be both handles set (same handle in both masks) so set to 1.
diff --git a/ace/SSL/SSL_SOCK_Stream.cpp b/ace/SSL/SSL_SOCK_Stream.cpp
index a8ef10df179..578051416d9 100644
--- a/ace/SSL/SSL_SOCK_Stream.cpp
+++ b/ace/SSL/SSL_SOCK_Stream.cpp
@@ -554,7 +554,7 @@ ACE_SSL_SOCK_Stream::get_remote_addr (ACE_Addr &addr) const
   // get_remote_addr() would be misleading.
 
   if (SSL_is_init_finished (this->ssl_))
-    return this->ACE_SOCK::get_remote_addr (addr);
+    return this->ACE_SSL_SOCK::get_remote_addr (addr);
 
   if (this->get_handle () == ACE_INVALID_HANDLE)
     errno = EBADF;
diff --git a/ace/SSL/SSL_SOCK_Stream.h b/ace/SSL/SSL_SOCK_Stream.h
index 981b931655d..06e5a4bd889 100644
--- a/ace/SSL/SSL_SOCK_Stream.h
+++ b/ace/SSL/SSL_SOCK_Stream.h
@@ -57,9 +57,6 @@
  */
 class ACE_SSL_Export ACE_SSL_SOCK_Stream : public ACE_SSL_SOCK
 {
-  friend class ACE_SSL_SOCK_Connector;
-  friend class ACE_SSL_SOCK_Acceptor;
-
 public:
 
   /// Constructor
diff --git a/ace/Select_Reactor_T.cpp b/ace/Select_Reactor_T.cpp
index ed1332ece07..78c3a3ada1f 100644
--- a/ace/Select_Reactor_T.cpp
+++ b/ace/Select_Reactor_T.cpp
@@ -1019,6 +1019,10 @@ ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::work_pending
   ACE_Time_Value *this_timeout =
     this->timer_queue_->calculate_timeout (&mwt, &timer_buf);
 
+  // Check if we have timers to fire.
+  int timers_pending =
+    (this_timeout != 0 && *this_timeout != max_wait_time ? 1 : 0);
+
   u_long width = (u_long) this->handler_rep_.max_handlep1 ();
 
   ACE_Select_Reactor_Handle_Set fd_set;
@@ -1026,11 +1030,15 @@ ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::work_pending
   fd_set.wr_mask_ = this->wait_set_.wr_mask_;
   fd_set.ex_mask_ = this->wait_set_.ex_mask_;
 
-  return ACE_OS::select (int (width),
-                         fd_set.rd_mask_,
-                         fd_set.wr_mask_,
-                         fd_set.ex_mask_,
-                         this_timeout);
+  int nfds = ACE_OS::select (int (width),
+                             fd_set.rd_mask_,
+                             fd_set.wr_mask_,
+                             fd_set.ex_mask_,
+                             this_timeout);
+
+  // If timers are pending, override any timeout from the select()
+  // call.
+  return (nfds == 0 && timers_pending != 0 ? 1 : nfds);
 }
 
 // Must be called with lock held.
diff --git a/ace/Service_Config.h b/ace/Service_Config.h
index 617bbfa9208..9c20e388519 100644
--- a/ace/Service_Config.h
+++ b/ace/Service_Config.h
@@ -21,15 +21,17 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/Service_Types.h"
-#include "ace/Signal.h"
 #include "ace/Unbounded_Queue.h"
 #include "ace/Unbounded_Set.h"
 #include "ace/SString.h"
 #include "ace/XML_Svc_Conf.h"
 
+
 // Forward decl.
+class ACE_Service_Type;
+class ACE_Service_Type_Impl;
 class ACE_Service_Repository;
+class ACE_Sig_Adapter;
 class ACE_Allocator;
 class ACE_Reactor;
 class ACE_Thread_Manager;
diff --git a/ace/Service_Manager.cpp b/ace/Service_Manager.cpp
index 8951d74f409..8d9ce8468a2 100644
--- a/ace/Service_Manager.cpp
+++ b/ace/Service_Manager.cpp
@@ -1,10 +1,9 @@
-// $Id$
-
 #include "ace/Get_Opt.h"
 #include "ace/Log_Msg.h"
 #include "ace/Service_Repository.h"
 #include "ace/Service_Config.h"
 #include "ace/Service_Manager.h"
+#include "ace/Service_Types.h"
 #include "ace/Reactor.h"
 #include "ace/WFMO_Reactor.h"
 
@@ -12,9 +11,13 @@
 #include "ace/Service_Manager.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(ace, Service_Manager, "$Id$")
 
-ACE_ALLOC_HOOK_DEFINE(ACE_Service_Manager)
+ACE_RCSID (ace,
+           Service_Manager,
+           "$Id$")
+
+
+ACE_ALLOC_HOOK_DEFINE (ACE_Service_Manager)
 
 void
 ACE_Service_Manager::dump (void) const
diff --git a/ace/Service_Repository.cpp b/ace/Service_Repository.cpp
index f6a1e3ce1f7..125c2e77b87 100644
--- a/ace/Service_Repository.cpp
+++ b/ace/Service_Repository.cpp
@@ -1,7 +1,5 @@
-// Service_Repository.cpp
-// $Id$
-
 #include "ace/Service_Repository.h"
+#include "ace/Service_Types.h"
 #include "ace/Object_Manager.h"
 #include "ace/Log_Msg.h"
 
@@ -9,7 +7,9 @@
 #include "ace/Service_Repository.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(ace, Service_Repository, "$Id$")
+ACE_RCSID (ace,
+           Service_Repository,
+           "$Id$")
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Service_Repository)
 
diff --git a/ace/Service_Repository.h b/ace/Service_Repository.h
index 46685807437..fa8bc699edb 100644
--- a/ace/Service_Repository.h
+++ b/ace/Service_Repository.h
@@ -1,4 +1,4 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -12,14 +12,21 @@
 
 #ifndef ACE_SERVICE_REPOSITORY_H
 #define ACE_SERVICE_REPOSITORY_H
+
 #include "ace/pre.h"
 
-#include "ace/Service_Types.h"
+#include "ace/ACE_export.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+#include "ace/Default_Constants.h"
+#include "ace/Synch.h"
+
+
+class ACE_Service_Type;
+
 #define ACE_Component_Repository ACE_Service_Repository
 /**
  * @class ACE_Service_Repository
@@ -200,4 +207,5 @@ private:
 #endif /* __ACE_INLINE__ */
 
 #include "ace/post.h"
+
 #endif /* _SERVICE_REPOSITORY_H */
diff --git a/ace/Strategies_T.cpp b/ace/Strategies_T.cpp
index eee0936a94e..28d15a4faf0 100644
--- a/ace/Strategies_T.cpp
+++ b/ace/Strategies_T.cpp
@@ -1,5 +1,3 @@
-// $Id$
-
 #ifndef ACE_STRATEGIES_T_C
 #define ACE_STRATEGIES_T_C
 
@@ -19,7 +17,11 @@
 #include "ace/Strategies_T.i"
 #endif /* ACE_LACKS_INLINE_FUNCTIONS */
 
-ACE_RCSID(ace, Strategies_T, "$Id$")
+
+ACE_RCSID (ace,
+           Strategies_T,
+           "$Id$")
+
 
 template <class SVC_HANDLER> int
 ACE_Singleton_Strategy<SVC_HANDLER>::open (SVC_HANDLER *sh,
@@ -408,7 +410,7 @@ ACE_Process_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *svc_handle
 
 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX>
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::ACE_Cached_Connect_Strategy
-(ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
+(creation_strategy_type *cre_s,
  ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
  ACE_Recycling_Strategy<SVC_HANDLER> *rec_s,
  MUTEX *lock,
@@ -467,8 +469,8 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::~ACE_Cach
   this->recycling_strategy_ = 0;
 
   // Close down all cached service handlers.
-  CONNECTION_MAP_ENTRY *entry;
-  for (CONNECTION_MAP_ITERATOR iterator (connection_map_);
+  CONNECTION_MAP::ENTRY *entry;
+  for (CONNECTION_MAP::ITERATOR iterator (connection_map_);
        iterator.next (entry);
        iterator.advance ())
     {
@@ -479,7 +481,7 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::~ACE_Cach
 
 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::open
-(ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
+(creation_strategy_type *cre_s,
  ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
  ACE_Recycling_Strategy<SVC_HANDLER> *rec_s)
 {
@@ -556,7 +558,7 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::check_hin
  int reuse_addr,
  int flags,
  int perms,
- ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry,
+ CONNECTION_MAP::ENTRY *&entry,
  int &found)
 {
   ACE_UNUSED_ARG (remote_addr);
@@ -569,7 +571,7 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::check_hin
   found = 0;
 
   // Get the recycling act for the svc_handler
-  CONNECTION_MAP_ENTRY *possible_entry = (CONNECTION_MAP_ENTRY *) sh->recycling_act ();
+  CONNECTION_MAP::ENTRY *possible_entry = (CONNECTION_MAP::ENTRY *) sh->recycling_act ();
 
   // Check to see if the hint svc_handler has been closed down
   if (possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED)
@@ -631,7 +633,7 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::find_or_c
  int reuse_addr,
  int flags,
  int perms,
- ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry,
+ CONNECTION_MAP::ENTRY *&entry,
  int &found)
 {
   // Explicit type conversion
@@ -884,7 +886,7 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::connect_s
  int perms,
  int& found)
 {
-  CONNECTION_MAP_ENTRY *entry = 0;
+  CONNECTION_MAP::ENTRY *entry = 0;
 
   // Check if the user passed a hint svc_handler
   if (sh != 0)
@@ -943,7 +945,8 @@ template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cache_i (const void *recycling_act)
 {
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast (CONNECTION_MAP::ENTRY *, recycling_act);
 
   // Mark the <svc_handler> in the cache as not being <in_use>.
   // Therefore recyclable is IDLE.
@@ -970,7 +973,8 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_s
                                                                                         ACE_Recyclable_State new_state)
 {
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast (CONNECTION_MAP::ENTRY *, recycling_act);
 
   // Mark the <svc_handler> in the cache as not being <in_use>.
   // Therefore recyclable is IDLE.
@@ -995,7 +999,8 @@ template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Recyclable_St
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_state_i (const void *recycling_act) const
 {
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast (CONNECTION_MAP::ENTRY *, recycling_act);
 
   // Mark the <svc_handler> in the cache as not being <in_use>.
   // Therefore recyclable is IDLE.
@@ -1016,7 +1021,8 @@ template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::purge_i (const void *recycling_act)
 {
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast (CONNECTION_MAP::ENTRY *, recycling_act);
 
   return this->connection_map_.unbind (entry);
 }
@@ -1035,7 +1041,8 @@ template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::mark_as_closed_i (const void *recycling_act)
 {
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast (CONNECTION_MAP::ENTRY *, recycling_act);
 
   // Mark the <svc_handler> in the cache as CLOSED.
   entry->ext_id_.recycle_state (ACE_RECYCLABLE_CLOSED);
@@ -1065,7 +1072,8 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cleanup_h
     *act_holder = 0;
 
   // The wonders and perils of ACT
-  CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
+  CONNECTION_MAP::ENTRY *entry =
+    ACE_static_cast, CONNECTION_MAP::ENTRY *, recycling_act);
 
   // Decrement the refcount on the <svc_handler>.
   int refcount = entry->ext_id_.decrement ();
@@ -1102,8 +1110,9 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::concurren
 }
 
 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
-ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::find (ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> &search_addr,
-                                                                             ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry)
+ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::find (
+  REFCOUNTED_HASH_RECYCLABLE_ADDRESS &search_addr,
+  CONNECTION_MAP::ENTRY *&entry)
 {
   typedef ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
                                        SVC_HANDLER *,
diff --git a/ace/Strategies_T.h b/ace/Strategies_T.h
index 8fb6d39f7f9..dcb9289b0d3 100644
--- a/ace/Strategies_T.h
+++ b/ace/Strategies_T.h
@@ -15,21 +15,20 @@
 
 #include "ace/pre.h"
 
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Hash_Map_Manager_T.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/Service_Config.h"
 #include "ace/Reactor.h"
-#include "ace/Synch_Options.h"
 #include "ace/Thread_Manager.h"
 #include "ace/Connection_Recycling_Strategy.h"
 #include "ace/Refcountable.h"
 #include "ace/Hashable.h"
 #include "ace/Recyclable.h"
 
+
 // Needed for broken linkers that can't grok long symbols.
 #define ACE_Refcounted_Hash_Recyclable ARHR
 
@@ -938,15 +937,15 @@ public:
   virtual int cleanup_hint (const void *recycling_act,
                             void **act_holder = 0);
 
-  // = Typedefs for managing the map
+  // = Traits for managing the map
   typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>
           REFCOUNTED_HASH_RECYCLABLE_ADDRESS;
-  typedef ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex>
+  typedef ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Null_Mutex>
           CONNECTION_MAP;
-  typedef ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex>
-          CONNECTION_MAP_ITERATOR;
-  typedef ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *>
-          CONNECTION_MAP_ENTRY;
+
+  // (Two) Deprecated and redundant typedefs
+  typedef CONNECTION_MAP::ITERATOR CONNECTION_MAP_ITERATOR;
+  typedef CONNECTION_MAP::ENTRY CONNECTION_MAP_ENTRY;
 
   typedef ACE_Reverse_Lock<MUTEX> REVERSE_MUTEX;
 
@@ -967,8 +966,8 @@ protected:
                               int perms);
 
   /// Find an idle handle.
-  int find (ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> &search_addr,
-            ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry);
+  int find (REFCOUNTED_HASH_RECYCLABLE_ADDRESS &search_addr,
+            CONNECTION_MAP::ENTRY *&entry);
 
   /// Remove from cache (non-locking version).
   virtual int purge_i (const void *recycling_act);
@@ -995,7 +994,7 @@ protected:
                     int reuse_addr,
                     int flags,
                     int perms,
-                    ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry,
+                    CONNECTION_MAP::ENTRY *&entry,
                     int &found);
 
   int find_or_create_svc_handler_i (SVC_HANDLER *&sh,
@@ -1005,17 +1004,18 @@ protected:
                                     int reuse_addr,
                                     int flags,
                                     int perms,
-                                    ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, SVC_HANDLER *> *&entry,
+                                    CONNECTION_MAP::ENTRY *&entry,
                                     int &found);
 
-  virtual int connect_svc_handler_i (SVC_HANDLER *&sh,
-                                     const ACE_PEER_CONNECTOR_ADDR &remote_addr,
-                                     ACE_Time_Value *timeout,
-                                     const ACE_PEER_CONNECTOR_ADDR &local_addr,
-                                     int reuse_addr,
-                                     int flags,
-                                     int perms,
-                                     int &found);
+  virtual int connect_svc_handler_i (
+    SVC_HANDLER *&sh,
+    const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+    ACE_Time_Value *timeout,
+    const ACE_PEER_CONNECTOR_ADDR &local_addr,
+    int reuse_addr,
+    int flags,
+    int perms,
+    int &found);
 
   /// Table that maintains the cache of connected <SVC_HANDLER>s.
   CONNECTION_MAP connection_map_;
diff --git a/ace/Svc_Conf.y b/ace/Svc_Conf.y
index a175ae35bea..002d4d59b00 100644
--- a/ace/Svc_Conf.y
+++ b/ace/Svc_Conf.y
@@ -8,11 +8,14 @@
 #include "ace/ARGV.h"
 #include "ace/Module.h"
 #include "ace/Stream.h"
+#include "ace/Service_Types.h"
+
 
 ACE_RCSID (ace,
            Svc_Conf_y,
            "$Id$")
 
+
 // Prototypes.
 static ACE_Module_Type *ace_get_module (ACE_Static_Node *str_rec,
                                         ACE_Static_Node *svc_type,
diff --git a/ace/Svc_Conf_y.cpp b/ace/Svc_Conf_y.cpp
index 426fccbb84c..c89c43fb9d9 100644
--- a/ace/Svc_Conf_y.cpp
+++ b/ace/Svc_Conf_y.cpp
@@ -28,11 +28,14 @@
 #include "ace/ARGV.h"
 #include "ace/Module.h"
 #include "ace/Stream.h"
+#include "ace/Service_Types.h"
+
 
 ACE_RCSID (ace,
            Svc_Conf_y,
            "$Id$")
 
+
 // Prototypes.
 static ACE_Module_Type *ace_get_module (ACE_Static_Node *str_rec,
                                         ACE_Static_Node *svc_type,
diff --git a/ace/Synch_Options.cpp b/ace/Synch_Options.cpp
index 0febeccfb29..0c7a1ba1951 100644
--- a/ace/Synch_Options.cpp
+++ b/ace/Synch_Options.cpp
@@ -1,14 +1,17 @@
-// $Id$
-
 #include "ace/Synch_Options.h"
 
 #if !defined (__ACE_INLINE__)
 #include "ace/Synch_Options.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(ace, Synch_Options, "$Id$")
+#include "ace/Trace.h"
+
+ACE_RCSID (ace,
+           Synch_Options,
+           "$Id$")
+
 
-ACE_ALLOC_HOOK_DEFINE(ACE_Synch_Options)
+ACE_ALLOC_HOOK_DEFINE (ACE_Synch_Options)
 
 void
 ACE_Synch_Options::dump (void) const
@@ -28,7 +31,7 @@ ACE_Synch_Options ACE_Synch_Options::synch;
 /* static */
 ACE_Synch_Options ACE_Synch_Options::asynch (ACE_Synch_Options::USE_REACTOR);
 
-ACE_Synch_Options::ACE_Synch_Options (u_long options,
+ACE_Synch_Options::ACE_Synch_Options (unsigned long options,
                                       const ACE_Time_Value &timeout,
                                       const void *arg)
 {
@@ -37,7 +40,7 @@ ACE_Synch_Options::ACE_Synch_Options (u_long options,
 }
 
 void
-ACE_Synch_Options::set (u_long options,
+ACE_Synch_Options::set (unsigned long options,
                         const ACE_Time_Value &timeout,
                         const void *arg)
 {
@@ -56,14 +59,14 @@ ACE_Synch_Options::set (u_long options,
 }
 
 int
-ACE_Synch_Options::operator[] (u_long option) const
+ACE_Synch_Options::operator[] (unsigned long option) const
 {
   ACE_TRACE ("ACE_Synch_Options::operator[]");
   return (this->options_ & option) != 0;
 }
 
 void
-ACE_Synch_Options::operator= (u_long option)
+ACE_Synch_Options::operator= (unsigned long option)
 {
   ACE_TRACE ("ACE_Synch_Options::operator=");
   this->options_ |= option;
diff --git a/ace/Synch_Options.h b/ace/Synch_Options.h
index 82953be7e1b..858f0ccebe3 100644
--- a/ace/Synch_Options.h
+++ b/ace/Synch_Options.h
@@ -21,7 +21,8 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/OS.h"
+#include "ace/Time_Value.h"
+
 
 /**
  * @class ACE_Synch_Options
@@ -76,7 +77,7 @@ public:
 
   // = Initialization methods.
   /// Initialize the Synch_Options based on parameters.
-  ACE_Synch_Options (u_long options = 0,
+  ACE_Synch_Options (unsigned long options = 0,
                      const ACE_Time_Value &timeout = ACE_Time_Value::zero,
                      const void *arg = 0);
 
@@ -84,15 +85,15 @@ public:
   ~ACE_Synch_Options (void);
 
   /// Initialize the Synch_Options based on parameters.
-  void set (u_long options = 0,
+  void set (unsigned long options = 0,
             const ACE_Time_Value &timeout = ACE_Time_Value::zero,
             const void *arg = 0);
 
   /// Get method for determining which options are enabled.
-  int operator[] (u_long option) const;
+  int operator[] (unsigned long option) const;
 
   /// Set method for enabling certain options.
-  void operator= (u_long option);
+  void operator= (unsigned long option);
 
   /// Returns the "magic cookie" argument.
   const void *arg (void) const;
@@ -135,7 +136,7 @@ public:
 
 private:
   /// Keeps track of the enabled options.
-  u_long options_;
+  unsigned long options_;
 
   /// Amount of time to wait for timeouts.
   ACE_Time_Value timeout_;
diff --git a/ace/Template_Instantiations.cpp b/ace/Template_Instantiations.cpp
index 0aa01515cc5..28f6aa318e7 100644
--- a/ace/Template_Instantiations.cpp
+++ b/ace/Template_Instantiations.cpp
@@ -227,9 +227,6 @@ template class ACE_TSS_Singleton<ACE_Dynamic, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Entry<ACE_NS_String, ACE_NS_Internal>;
 template class ACE_Hash<ACE_NS_String>;
 template class ACE_Equal_To<ACE_NS_String>;
-template class ACE_Hash_Map_Manager<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_NS_String, ACE_NS_Internal, ACE_Hash<ACE_NS_String>, ACE_Equal_To<ACE_NS_String>, ACE_Null_Mutex>;
@@ -245,9 +242,6 @@ template class ACE_Map_Iterator_Base<ACE_NS_String, ACE_NS_Internal, ACE_Null_Mu
 // from Filecache.cpp
 #if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
 template class ACE_Hash_Map_Entry<const char *, ACE_Filecache_Object *>;
-template class ACE_Hash_Map_Manager<const char *, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<const char *, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<const char *, ACE_Filecache_Object *, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<const char *, ACE_Filecache_Object *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Base_Ex<const char *, ACE_Filecache_Object *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<const char *, ACE_Filecache_Object *, ACE_Hash<const char *>, ACE_Equal_To<const char *>, ACE_Null_Mutex>;
@@ -256,9 +250,6 @@ template class ACE_Hash_Map_Reverse_Iterator_Ex<const char *, ACE_Filecache_Obje
 template class ACE_Hash_Map_Entry<ACE_TString, ACE_Filecache_Object *>;
 template class ACE_Hash<ACE_TString>;
 template class ACE_Equal_To<ACE_TString>;
-template class ACE_Hash_Map_Manager<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_TString, ACE_Filecache_Object *, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Manager_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Base_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
 template class ACE_Hash_Map_Iterator_Ex<ACE_TString, ACE_Filecache_Object *, ACE_Hash<ACE_TString>, ACE_Equal_To<ACE_TString>, ACE_Null_Mutex>;
diff --git a/ace/Token_Collection.cpp b/ace/Token_Collection.cpp
index e362d9e2aed..291a0f3a450 100644
--- a/ace/Token_Collection.cpp
+++ b/ace/Token_Collection.cpp
@@ -1,5 +1,3 @@
-// $Id$
-
 #include "ace/Token_Collection.h"
 
 #if !defined (__ACE_INLINE__)
@@ -8,7 +6,11 @@
 
 #if defined (ACE_HAS_TOKENS_LIBRARY)
 
-ACE_RCSID(ace, Token_Collection, "$Id$")
+
+ACE_RCSID (ace,
+           Token_Collection,
+           "$Id$")
+
 
 ACE_Token_Collection::ACE_Token_Collection (int debug,
 					    const ACE_TCHAR *name)
@@ -78,9 +80,9 @@ ACE_Token_Collection::acquire (int notify,
 {
   ACE_TRACE ("ACE_Token_Collection::acquire");
 
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
@@ -143,9 +145,9 @@ ACE_Token_Collection::tryacquire (void (*sleep_hook)(void *))
 {
   ACE_TRACE ("ACE_Token_Collection::tryacquire");
 
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
@@ -166,9 +168,9 @@ ACE_Token_Collection::renew (int requeue_position,
 {
   ACE_TRACE ("ACE_Token_Collection::renew");
 
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
@@ -208,9 +210,9 @@ ACE_Token_Collection::release (ACE_Synch_Options &)
 
 {
   ACE_TRACE ("ACE_Token_Collection::release");
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
@@ -242,15 +244,15 @@ ACE_Token_Collection::release (const ACE_TCHAR *token_name,
 ACE_Token_Collection::~ACE_Token_Collection (void)
 {
   ACE_TRACE ("ACE_Token_Collection::~ACE_Token_Collection");
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
       delete temp->int_id_;
       // The ext_id_'s delete themselves when the array of
-      // COLLECTION_ENTRYs goes away.
+      // COLLECTION::ENTRYs goes away.
     }
 }
 
diff --git a/ace/Token_Collection.h b/ace/Token_Collection.h
index 3c6e4297214..60ecf8270e6 100644
--- a/ace/Token_Collection.h
+++ b/ace/Token_Collection.h
@@ -202,12 +202,18 @@ protected:
     COLLECTION;
 
   /// Allows iterations through collection_
-  typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Token_Proxy *, ACE_Null_Mutex>
-    COLLECTION_ITERATOR;
+  /**
+   * @note Deprecated typedef.  Use COLLECTION::ITERATOR trait
+   *       instead.
+   */
+  typedef COLLECTION::ITERATOR COLLECTION_ITERATOR;
 
   /// Allows iterations through collection_
-  typedef ACE_Map_Entry<TOKEN_NAME, ACE_Token_Proxy *>
-    COLLECTION_ENTRY;
+  /**
+   * @note Deprecated typedef.  Use COLLECTION::ENTRY trait
+   *       instead.
+   */
+  typedef COLLECTION::ENTRY COLLECTION_ENTRY;
 
   /// COLLECTION maintains a mapping from token names to ACE_Tokens*.
   COLLECTION collection_;
diff --git a/ace/Token_Invariants.cpp b/ace/Token_Invariants.cpp
index e709e1ea65b..69f2c8fd32b 100644
--- a/ace/Token_Invariants.cpp
+++ b/ace/Token_Invariants.cpp
@@ -1,11 +1,13 @@
-// $Id$
-
 #include "ace/Token_Invariants.h"
 #include "ace/Object_Manager.h"
 
 #if defined (ACE_HAS_TOKENS_LIBRARY)
 
-ACE_RCSID(ace, Token_Invariants, "$Id$")
+
+ACE_RCSID (ace,
+           Token_Invariants,
+           "$Id$")
+
 
 ACE_Token_Invariant_Manager *ACE_Token_Invariant_Manager::instance_ = 0;
 
@@ -203,16 +205,17 @@ ACE_Token_Invariant_Manager::get_rwlock (const ACE_TCHAR *token_name,
 ACE_Token_Invariant_Manager::~ACE_Token_Invariant_Manager (void)
 {
   ACE_TRACE ("ACE_Token_Invariant_Manager::~ACE_Token_Invariant_Manager");
-  MUTEX_COLLECTION_ITERATOR iterator (mutex_collection_);
 
-  for (MUTEX_COLLECTION_ENTRY *temp = 0;
+  MUTEX_COLLECTION::ITERATOR iterator (mutex_collection_);
+
+  for (MUTEX_COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     delete temp->int_id_;
 
-  RWLOCK_COLLECTION_ITERATOR iterator2 (rwlock_collection_);
+  RWLOCK_COLLECTION::ITERATOR iterator2 (rwlock_collection_);
 
-  for (RWLOCK_COLLECTION_ENTRY *temp2 = 0;
+  for (RWLOCK_COLLECTION::ENTRY *temp2 = 0;
        iterator2.next (temp2) != 0;
        iterator2.advance ())
     delete temp2->int_id_;
diff --git a/ace/Token_Invariants.h b/ace/Token_Invariants.h
index e5c10ebaed6..84372a731a5 100644
--- a/ace/Token_Invariants.h
+++ b/ace/Token_Invariants.h
@@ -1,4 +1,4 @@
-/* -*- C++ -*- */
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -193,12 +193,18 @@ protected:
     MUTEX_COLLECTION;
 
   /// Allows iterations through collection.
-  typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Mutex_Invariants *, ACE_Null_Mutex>
-    MUTEX_COLLECTION_ITERATOR;
+  /**
+   * @note Deprecated typedef.  Use MUTEX_COLLECTION::ITERATOR trait
+   *       instead.
+   */
+  typedef MUTEX_COLLECTION::ITERATOR MUTEX_COLLECTION_ITERATOR;
 
   /// Allows iterations through collection.
-  typedef ACE_Map_Entry<TOKEN_NAME, ACE_Mutex_Invariants *>
-    MUTEX_COLLECTION_ENTRY;
+  /**
+   * @note Deprecated typedef.  Use MUTEX_COLLECTION::ENTRY trait
+   *       instead.
+   */
+  typedef MUTEX_COLLECTION::ENTRY MUTEX_COLLECTION_ENTRY;
 
   /// MUTEX_COLLECTION maintains a mapping from token names to mutexes.
   MUTEX_COLLECTION mutex_collection_;
@@ -208,12 +214,18 @@ protected:
     RWLOCK_COLLECTION;
 
   /// Allows iterations through collection.
-  typedef ACE_Map_Iterator<TOKEN_NAME, ACE_RWLock_Invariants *, ACE_Null_Mutex>
-    RWLOCK_COLLECTION_ITERATOR;
+  /**
+   * @note Deprecated typedef.  Use RWLOCK_COLLECTION::ITERATOR trait
+   *       instead.
+   */
+  typedef RWLOCK_COLLECTION::ITERATOR RWLOCK_COLLECTION_ITERATOR;
 
   /// Allows iterations through collection.
-  typedef ACE_Map_Entry<TOKEN_NAME, ACE_RWLock_Invariants *>
-    RWLOCK_COLLECTION_ENTRY;
+  /**
+   * @note Deprecated typedef.  Use RWLOCK_COLLECTION::ENTRY trait
+   *       instead.
+   */
+  typedef RWLOCK_COLLECTION::ENTRY RWLOCK_COLLECTION_ENTRY;
 
   /// MUTEX_COLLECTION maintains a mapping from token names to mutexes.
   RWLOCK_COLLECTION rwlock_collection_;
diff --git a/ace/Token_Manager.cpp b/ace/Token_Manager.cpp
index 13e21c361fc..d14871ab52c 100644
--- a/ace/Token_Manager.cpp
+++ b/ace/Token_Manager.cpp
@@ -1,5 +1,3 @@
-// $Id$
-
 #include "ace/Token_Manager.h"
 #include "ace/Object_Manager.h"
 
@@ -9,7 +7,9 @@
 
 #if defined (ACE_HAS_TOKENS_LIBRARY)
 
-ACE_RCSID(ace, Token_Manager, "$Id$")
+ACE_RCSID (ace,
+           Token_Manager,
+           "$Id$")
 
 // singleton token manager
 ACE_Token_Manager *ACE_Token_Manager::token_manager_ = 0;
@@ -23,16 +23,16 @@ ACE_Token_Manager::~ACE_Token_Manager ()
 {
   ACE_TRACE ("ACE_Token_Manager::~ACE_Token_Manager");
 
-  COLLECTION_ITERATOR iterator (collection_);
+  COLLECTION::ITERATOR iterator (collection_);
 
-  for (COLLECTION_ENTRY *temp = 0;
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
       // @ should I be doing an unbind here?
       delete temp->int_id_;
       // The ext_id_'s delete themselves when the array of
-      // COLLECTION_ENTRYs goes away.
+      // COLLECTION::ENTRYs goes away.
     }
 }
 
@@ -119,8 +119,8 @@ ACE_Token_Manager::check_deadlock (ACE_Token_Proxy *proxy)
 
   // Whether or not we detect deadlock, we have to unmark all tokens
   // for the next time.
-  COLLECTION_ITERATOR iterator (collection_);
-  for (COLLECTION_ENTRY *temp = 0;
+  COLLECTION::ITERATOR iterator (collection_);
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
       temp->int_id_->visit (0);
@@ -193,8 +193,8 @@ ACE_Token_Manager::check_deadlock (ACE_Tokens *token, ACE_Token_Proxy *proxy)
 ACE_Tokens *
 ACE_Token_Manager::token_waiting_for (const ACE_TCHAR *client_id)
 {
-  COLLECTION_ITERATOR iterator (collection_);
-  for (COLLECTION_ENTRY *temp = 0;
+  COLLECTION::ITERATOR iterator (collection_);
+  for (COLLECTION::ENTRY *temp = 0;
        iterator.next (temp) != 0;
        iterator.advance ())
     {
diff --git a/ace/Token_Manager.h b/ace/Token_Manager.h
index df01b2f5bfb..15b17624b40 100644
--- a/ace/Token_Manager.h
+++ b/ace/Token_Manager.h
@@ -117,12 +117,18 @@ private:
   COLLECTION;
 
   /// Allows iterations through collection_
-  typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
-  COLLECTION_ITERATOR;
+  /**
+   * @note Deprecated typedef.  Use COLLECTION::ITERATOR trait
+   *       instead.
+   */
+  typedef COLLECTION::ITERATOR COLLECTION_ITERATOR;
 
   /// Allows iterations through collection_
-  typedef ACE_Map_Entry<TOKEN_NAME, ACE_Tokens *>
-  COLLECTION_ENTRY;
+  /**
+   * @note Deprecated typedef.  Use COLLECTION::ENTRY trait
+   *       instead.
+   */
+  typedef COLLECTION::ENTRY COLLECTION_ENTRY;
 
   /// COLLECTION maintains a mapping from token names to ACE_Tokens*.
   COLLECTION collection_;
diff --git a/ace/WIN32_Asynch_IO.cpp b/ace/WIN32_Asynch_IO.cpp
index 1e35396546f..0300f1d6f76 100644
--- a/ace/WIN32_Asynch_IO.cpp
+++ b/ace/WIN32_Asynch_IO.cpp
@@ -1,8 +1,8 @@
-// $Id$
-
 #include "ace/WIN32_Asynch_IO.h"
 
-// ACE_RCSID(ace, Asynch_IO, "$Id$")
+ACE_RCSID (ace,
+           Win32_Asynch_IO,
+           "$Id$")
 
 #if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
 
@@ -218,18 +218,25 @@ ACE_WIN32_Asynch_Read_Stream_Result::handle (void) const
   return this->handle_;
 }
 
-ACE_WIN32_Asynch_Read_Stream_Result::ACE_WIN32_Asynch_Read_Stream_Result (ACE_Handler &handler,
-                                                                          ACE_HANDLE handle,
-                                                                          ACE_Message_Block &message_block,
-                                                                          size_t bytes_to_read,
-                                                                          const void* act,
-                                                                          ACE_HANDLE event,
-                                                                          int priority,
-                                                                          int signal_number,
-                                                                          int scatter_enabled)
+ACE_WIN32_Asynch_Read_Stream_Result::ACE_WIN32_Asynch_Read_Stream_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_read,
+  const void* act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number,
+  int scatter_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_WIN32_Asynch_Result (handler,
+                             act,
+                             event,
+                             0,
+                             0,
+                             priority,
+                             signal_number),
     bytes_to_read_ (bytes_to_read),
     message_block_ (message_block),
     handle_ (handle),
@@ -633,15 +640,16 @@ ACE_WIN32_Asynch_Write_Stream_Result::handle (void) const
   return this->handle_;
 }
 
-ACE_WIN32_Asynch_Write_Stream_Result::ACE_WIN32_Asynch_Write_Stream_Result (ACE_Handler &handler,
-                                                                            ACE_HANDLE handle,
-                                                                            ACE_Message_Block &message_block,
-                                                                            size_t bytes_to_write,
-                                                                            const void* act,
-                                                                            ACE_HANDLE event,
-                                                                            int priority,
-                                                                            int signal_number,
-                                                                            int gather_enabled)
+ACE_WIN32_Asynch_Write_Stream_Result::ACE_WIN32_Asynch_Write_Stream_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_write,
+  const void* act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number,
+  int gather_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
     ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
@@ -1025,17 +1033,18 @@ ACE_WIN32_Asynch_Write_Stream::proactor (void) const
   return ACE_WIN32_Asynch_Operation::proactor ();
 }
 
-ACE_WIN32_Asynch_Read_File_Result::ACE_WIN32_Asynch_Read_File_Result (ACE_Handler &handler,
-                                                                      ACE_HANDLE handle,
-                                                                      ACE_Message_Block &message_block,
-                                                                      size_t bytes_to_read,
-                                                                      const void* act,
-                                                                      u_long offset,
-                                                                      u_long offset_high,
-                                                                      ACE_HANDLE event,
-                                                                      int priority,
-                                                                      int signal_number,
-                                                                      int scatter_enabled)
+ACE_WIN32_Asynch_Read_File_Result::ACE_WIN32_Asynch_Read_File_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_read,
+  const void* act,
+  u_long offset,
+  u_long offset_high,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number,
+  int scatter_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Stream_Result_Impl (),
     ACE_Asynch_Read_File_Result_Impl (),
@@ -1424,17 +1433,18 @@ ACE_WIN32_Asynch_Read_File::proactor (void) const
   return ACE_WIN32_Asynch_Operation::proactor ();
 }
 
-ACE_WIN32_Asynch_Write_File_Result::ACE_WIN32_Asynch_Write_File_Result (ACE_Handler &handler,
-                                                                        ACE_HANDLE handle,
-                                                                        ACE_Message_Block &message_block,
-                                                                        size_t bytes_to_write,
-                                                                        const void* act,
-                                                                        u_long offset,
-                                                                        u_long offset_high,
-                                                                        ACE_HANDLE event,
-                                                                        int priority,
-                                                                        int signal_number,
-                                                                        int gather_enabled)
+ACE_WIN32_Asynch_Write_File_Result::ACE_WIN32_Asynch_Write_File_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_write,
+  const void* act,
+  u_long offset,
+  u_long offset_high,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number,
+  int gather_enabled)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Stream_Result_Impl (),
     ACE_Asynch_Write_File_Result_Impl (),
@@ -1852,18 +1862,25 @@ ACE_WIN32_Asynch_Accept_Result::accept_handle (void) const
   return this->accept_handle_;
 }
 
-ACE_WIN32_Asynch_Accept_Result::ACE_WIN32_Asynch_Accept_Result (ACE_Handler &handler,
-                                                                ACE_HANDLE listen_handle,
-                                                                ACE_HANDLE accept_handle,
-                                                                ACE_Message_Block &message_block,
-                                                                size_t bytes_to_read,
-                                                                const void* act,
-                                                                ACE_HANDLE event,
-                                                                int priority,
-                                                                int signal_number)
+ACE_WIN32_Asynch_Accept_Result::ACE_WIN32_Asynch_Accept_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE listen_handle,
+  ACE_HANDLE accept_handle,
+  ACE_Message_Block &message_block,
+  size_t bytes_to_read,
+  const void* act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Accept_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_WIN32_Asynch_Result (handler,
+                             act,
+                             event,
+                             0,
+                             0,
+                             priority,
+                             signal_number),
     bytes_to_read_ (bytes_to_read),
     message_block_ (message_block),
     listen_handle_ (listen_handle),
@@ -2563,9 +2580,9 @@ ACE_WIN32_Asynch_Connect::cancel_uncompleted (int flg_notify, ACE_Handle_Set & s
 
   int retval = 0;
 
-  MAP_ITERATOR iter (result_map_);
+  MAP_MANAGER::ITERATOR iter (result_map_);
 
-  MAP_ENTRY *   me = 0;
+  MAP_MANAGER::ENTRY *   me = 0;
 
   set.reset ();
 
@@ -2805,22 +2822,29 @@ ACE_WIN32_Asynch_Transmit_File_Result::flags (void) const
   return this->flags_;
 }
 
-ACE_WIN32_Asynch_Transmit_File_Result::ACE_WIN32_Asynch_Transmit_File_Result (ACE_Handler &handler,
-                                                                              ACE_HANDLE socket,
-                                                                              ACE_HANDLE file,
-                                                                              ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
-                                                                              size_t bytes_to_write,
-                                                                              u_long offset,
-                                                                              u_long offset_high,
-                                                                              size_t bytes_per_send,
-                                                                              u_long flags,
-                                                                              const void *act,
-                                                                              ACE_HANDLE event,
-                                                                              int priority,
-                                                                              int signal_number)
+ACE_WIN32_Asynch_Transmit_File_Result::ACE_WIN32_Asynch_Transmit_File_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE socket,
+  ACE_HANDLE file,
+  ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
+  size_t bytes_to_write,
+  u_long offset,
+  u_long offset_high,
+  size_t bytes_per_send,
+  u_long flags,
+  const void *act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Transmit_File_Result_Impl (),
-    ACE_WIN32_Asynch_Result (handler, act, event, offset, offset_high, priority, signal_number),
+    ACE_WIN32_Asynch_Result (handler,
+                             act,
+                             event,
+                             offset,
+                             offset_high,
+                             priority,
+                             signal_number),
     socket_ (socket),
     file_ (file),
     header_and_trailer_ (header_and_trailer),
@@ -3186,16 +3210,17 @@ ACE_WIN32_Asynch_Read_Dgram_Result::post_completion (ACE_Proactor_Impl *proactor
   return ACE_WIN32_Asynch_Result::post_completion (proactor);
 }
 
-ACE_WIN32_Asynch_Read_Dgram_Result::ACE_WIN32_Asynch_Read_Dgram_Result (ACE_Handler &handler,
-                                                                        ACE_HANDLE handle,
-                                                                        ACE_Message_Block *message_block,
-                                                                        size_t bytes_to_read,
-                                                                        int flags,
-                                                                        int protocol_family,
-                                                                        const void* act,
-                                                                        ACE_HANDLE event,
-                                                                        int priority,
-                                                                        int signal_number)
+ACE_WIN32_Asynch_Read_Dgram_Result::ACE_WIN32_Asynch_Read_Dgram_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block *message_block,
+  size_t bytes_to_read,
+  int flags,
+  int protocol_family,
+  const void* act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Read_Dgram_Result_Impl(),
     ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
@@ -3516,18 +3541,25 @@ ACE_WIN32_Asynch_Write_Dgram_Result::post_completion (ACE_Proactor_Impl *proacto
   return ACE_WIN32_Asynch_Result::post_completion (proactor);
 }
 
-ACE_WIN32_Asynch_Write_Dgram_Result::ACE_WIN32_Asynch_Write_Dgram_Result (ACE_Handler &handler,
-                                                                          ACE_HANDLE handle,
-                                                                          ACE_Message_Block *message_block,
-                                                                          size_t bytes_to_write,
-                                                                          int flags,
-                                                                          const void* act,
-                                                                          ACE_HANDLE event,
-                                                                          int priority,
-                                                                          int signal_number)
+ACE_WIN32_Asynch_Write_Dgram_Result::ACE_WIN32_Asynch_Write_Dgram_Result (
+  ACE_Handler &handler,
+  ACE_HANDLE handle,
+  ACE_Message_Block *message_block,
+  size_t bytes_to_write,
+  int flags,
+  const void* act,
+  ACE_HANDLE event,
+  int priority,
+  int signal_number)
   : ACE_Asynch_Result_Impl (),
     ACE_Asynch_Write_Dgram_Result_Impl(),
-    ACE_WIN32_Asynch_Result (handler, act, event, 0, 0, priority, signal_number),
+    ACE_WIN32_Asynch_Result (handler,
+                             act,
+                             event,
+                             0,
+                             0,
+                             priority,
+                             signal_number),
     bytes_to_write_ (bytes_to_write),
     message_block_ (message_block),
     flags_ (flags),
diff --git a/ace/WIN32_Asynch_IO.h b/ace/WIN32_Asynch_IO.h
index 6b48755b9ec..cbed064d077 100644
--- a/ace/WIN32_Asynch_IO.h
+++ b/ace/WIN32_Asynch_IO.h
@@ -1338,10 +1338,11 @@ private:
 
   typedef ACE_Map_Manager<ACE_HANDLE, ACE_WIN32_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
           MAP_MANAGER;
-  typedef ACE_Map_Iterator<ACE_HANDLE, ACE_WIN32_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
-          MAP_ITERATOR;
-  typedef ACE_Map_Entry<ACE_HANDLE, ACE_WIN32_Asynch_Connect_Result *>
-          MAP_ENTRY;
+
+  // (Two) Deprecated typedefs.  Use appropriate MAP_MANAGER traits
+  // instead.
+  typedef MAP_MANAGER::ITERATOR MAP_ITERATOR;
+  typedef MAP_MANAGER::ENTRY MAP_ENTRY;
 
   /// Map of Result pointers that correspond to all the <accept>'s
   /// pending.