ChangeLogTag:Wed

author: schmidt <douglascraigschmidt@users.noreply.github.com> 2013-04-24 15:01:48 +0000
committer: schmidt <douglascraigschmidt@users.noreply.github.com> 2013-04-24 15:01:48 +0000
commit: 4a2b25b62b35e57b7ee5a677575a4a94c106c1a8 (patch)
tree: c506664051fc00b667c8be8ea6f917ff893ac1e6
parent: be48c1011fb0bda61530415d9af16f88322582b8 (diff)
download: ATCD-4a2b25b62b35e57b7ee5a677575a4a94c106c1a8.tar.gz
14 files changed, 588 insertions, 564 deletions
diff --git a/ACE/ACE-INSTALL.html b/ACE/ACE-INSTALL.html
index 62cf735d010..d1070b665a4 100644
--- a/ACE/ACE-INSTALL.html
+++ b/ACE/ACE-INSTALL.html
@@ -1,4 +1,4 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+http://www.dre.vanderbilt.edu/~schmidt/PDF/Svc-Conf.pdf<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html><head><!-- $Id$ -->
   <meta content="text/html; charset=ISO-8859-1" http-equiv="content-type"><title>Building and Installing ACE and Its Auxiliary Libraries and Services</title>
 
diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index 3740f85f730..b89b4819c38 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,35 @@
+Wed Apr 24 14:43:25 UTC 2013  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/Acceptor.{h,cpp}, ace/Connector.{h,cpp},
+          ace/Svc_Handler.{h,cpp}: Replaced all the obsolete
+          ACE_PEER_{STREAM,ACCEPTOR,CONNECTOR} macros that have been
+          deprecated.  Thanks to Clyde Gerber <clyde_gerber at symantec
+          dot com> for motivating this.
+
+Wed Apr 24 14:42:50 UTC 2013  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/Global_Macros.h: Added comments that indicate the
+          ACE_PEER_{STREAM,ACCEPTOR,CONNECTOR} macros have been
+          deprecated.  Thanks to Clyde Gerber <clyde_gerber at symantec
+          dot com> for motivating this.
+
+Wed Apr 24 13:57:02 UTC 2013  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/Svc_Handler.{h,cpp}: Zapped the obsolete ACE_PEER_STREAM*
+          macros since compilers that ACE supports now should handle the
+          traits classes properly.
+
+Thu Apr 18 16:42:03 UTC 2013  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/Svc_Handler.h: Updated the documentation for
+          ACE_Svc_Handler::open() method.  Thanks to Andreas Florath
+          <andreas at florath dot org> for motivating this.
+
+Mon Apr 15 01:59:34 UTC 2013  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * examples/Connection/misc/Connection_Handler.cpp: Improved the
+          documentation.
+
 Mon Apr 22 14:43:53 UTC 2013  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * ace/Hash_Map_Manager_T.inl:
@@ -92,6 +124,7 @@ Fri Apr 12 19:30:05 UTC 2013  Huang-Ming Huang  <huangh@ociweb.com>
         * tests/Log_Msg_Test.cpp:
         Fixed problem for WCHAR build
 
+>>>>>>> .r97068
 Thu Apr 11 19:53:22 UTC 2013  Huang-Ming Huang  <huangh@ociweb.com>
 
         * ace/Log_Category.h:
diff --git a/ACE/THANKS b/ACE/THANKS
index 0193e0fbce7..b9ac37833d2 100644
--- a/ACE/THANKS
+++ b/ACE/THANKS
@@ -2378,6 +2378,8 @@ Phillip LaBanca <labancap at ociweb dot com>
 Journeyer J. Joh <oosaprogrammer at gmail dot com>
 Rudy Pot <rpot at aweta dot nl>
 Neil Youngman <ny at youngman dot org dot uk>
+Andreas Florath <andreas at florath dot org>
+Clyde Gerber <clyde_gerber at symantec dot com>
 
 I would particularly like to thank Paul Stephenson, who worked with me
 at Ericsson in the early 1990's.  Paul devised the recursive Makefile
diff --git a/ACE/ace/Acceptor.cpp b/ACE/ace/Acceptor.cpp
index e480a29ecf1..fdd53a4720c 100644
--- a/ACE/ace/Acceptor.cpp
+++ b/ACE/ace/Acceptor.cpp
@@ -19,11 +19,11 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Acceptor)
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> void
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump");
 
   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->peer_acceptor_.dump ();
@@ -31,26 +31,26 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR & () const
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
-  return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR &");
+  return (PEER_ACCEPTOR &) this->peer_acceptor_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> PEER_ACCEPTOR &
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor (void) const
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
-  return const_cast<ACE_PEER_ACCEPTOR &> (this->peer_acceptor_);
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor");
+  return const_cast<PEER_ACCEPTOR &> (this->peer_acceptor_);
 }
 
 // Returns ACE_HANDLE of the underlying Acceptor_Strategy.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> ACE_HANDLE
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle (void) const
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle");
   return this->peer_acceptor_.get_handle ();
 }
 
@@ -59,15 +59,15 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
 // with the Reactor and listen for connection requests at the
 // designated <local_addr>.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
-  (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open
+  (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
    ACE_Reactor *reactor,
    int flags,
    int use_select,
    int reuse_addr)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open");
   this->flags_ = flags;
   this->use_select_ = use_select;
   this->reuse_addr_ = reuse_addr;
@@ -81,6 +81,7 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
       return -1;
     }
 
+  // Open the underlying PEER_ACCEPTOR.
   if (this->peer_acceptor_.open (local_addr, reuse_addr) == -1)
     return -1;
 
@@ -104,27 +105,27 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
 
 // Simple constructor.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor (ACE_Reactor *reactor,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Acceptor (ACE_Reactor *reactor,
                                                               int use_select)
   :flags_ (0),
    use_select_ (use_select),
    reuse_addr_ (1)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Acceptor");
 
   this->reactor (reactor);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor
-  (const ACE_PEER_ACCEPTOR_ADDR &addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Acceptor
+  (const typename PEER_ACCEPTOR::PEER_ADDR &addr,
    ACE_Reactor *reactor,
    int flags,
    int use_select,
    int reuse_addr)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Acceptor");
 
   if (this->open (addr,
                   reactor,
@@ -136,37 +137,37 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor
                 ACE_TEXT ("ACE_Acceptor::ACE_Acceptor")));
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Acceptor (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Acceptor (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Acceptor");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Acceptor");
   this->handle_close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
-  return ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close ();
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini");
+  return ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close ();
 }
 
 // Hook called by the explicit dynamic linking facility.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init (int, ACE_TCHAR *[])
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::init (int, ACE_TCHAR *[])
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::init");
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::info (ACE_TCHAR **strp,
                                                       size_t length) const
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::info");
   ACE_TCHAR buf[BUFSIZ];
   ACE_TCHAR addr_str[BUFSIZ];
-  ACE_PEER_ACCEPTOR_ADDR addr;
+  typename PEER_ACCEPTOR::PEER_ADDR addr;
 
   if (this->acceptor ().get_local_addr (addr) == -1)
     return -1;
@@ -186,42 +187,42 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
   return static_cast<int> (ACE_OS::strlen (buf));
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend");
   return this->reactor ()->suspend_handler (this);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume");
   return this->reactor ()->resume_handler (this);
 }
 
 // Perform termination activities when <this> is removed from the
 // <reactor>.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::close (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::close");
   return this->handle_close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_accept_error (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_accept_error (void)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_accept_error");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_accept_error");
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close (ACE_HANDLE,
                                                               ACE_Reactor_Mask)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close");
   // Guard against multiple closes.
   if (this->reactor () != 0)
     {
@@ -252,10 +253,10 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
 // subclass instances of SVC_HANDLER, using a singleton, dynamically
 // linking the handler, etc.).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::make_svc_handler (SVC_HANDLER *&sh)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::make_svc_handler");
 
   if (sh == 0)
     ACE_NEW_RETURN (sh,
@@ -272,11 +273,11 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_HANDLER *&
 // <svc_handler>.  The default behavior delegates to the
 // <PEER_ACCEPTOR::accept> in the Acceptor_Strategy.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept_svc_handler
   (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept_svc_handler");
 
   // Try to find out if the implementation of the reactor that we are
   // using requires us to reset the event association for the newly
@@ -326,11 +327,11 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
 // concurrency activations (such as creating the SVC_HANDLER as an
 // "active object" via multi-threading or multi-processing).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler
   (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler");
 
   int result = 0;
 
@@ -361,10 +362,10 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
 // creation strategy), accept the connection into the SVC_HANDLER, and
 // then activate the SVC_HANDLER.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE listener)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_input (ACE_HANDLE listener)
 {
-  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input");
+  ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_input");
 
   // Default is "timeout (0, 0)," which means "poll."
   ACE_Time_Value timeout;
@@ -450,38 +451,38 @@ ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE listene
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Strategy_Acceptor)
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend (void)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend");
 
   // First suspend the SVC_HANDLER's we've created.
   if (this->scheduling_strategy_->suspend () == -1)
     return -1;
   else   // Then suspend ourselves.
-    return ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend ();
+    return ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume (void)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume");
 
   // First resume ourselves.
-  if (ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume () == -1)
+  if (ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume () == -1)
     return -1;
   else // Then resume the SVC_HANDLER's we've created.
     return this->scheduling_strategy_->resume ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> void
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump");
 
   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump ();
+  ACE_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump ();
   this->creation_strategy_->dump ();
   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_creation_strategy_ = %d"), delete_creation_strategy_));
   this->accept_strategy_->dump ();
@@ -499,26 +500,26 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> PEER_ACCEPTOR &
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor (void) const
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor");
   return this->accept_strategy_->acceptor ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR & () const
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR &");
   return this->accept_strategy_->acceptor ();
 }
 
 // Returns ACE_HANDLE of the underlying Acceptor_Strategy.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> ACE_HANDLE
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle (void) const
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle");
   return this->accept_strategy_->get_handle ();
 }
 
@@ -526,26 +527,26 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
 // connection acceptance, and concurrency, and then register <this>
 // with the Reactor and listen for connection requests at the
 // designated <local_addr>.
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
-  (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open
+  (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
    ACE_Reactor *reactor,
    int /* flags unused */,
    int use_select,
    int reuse_addr)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open");
   return this->open
     (local_addr, reactor, 0, 0, 0, 0, 0, 0, use_select, reuse_addr);
 }
 
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
-  (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open
+  (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
    ACE_Reactor *reactor,
    ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
-   ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> *acc_s,
+   ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> *acc_s,
    ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
    ACE_Scheduling_Strategy<SVC_HANDLER> *sch_s,
    const ACE_TCHAR *service_name,
@@ -553,7 +554,7 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
    int use_select,
    int reuse_addr)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open");
 
   if (this->service_name_ == 0 && service_name != 0)
     ACE_ALLOCATOR_RETURN (this->service_name_,
@@ -637,8 +638,8 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
 
 // Simple constructor.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Strategy_Acceptor
   (const ACE_TCHAR service_name[],
    const ACE_TCHAR service_description[],
    int use_select,
@@ -654,7 +655,7 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
       service_name_ (0),
       service_description_ (0)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Strategy_Acceptor");
 
   if (service_name != 0)
     ACE_ALLOCATOR (this->service_name_,
@@ -666,12 +667,12 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
   this->reuse_addr_ = reuse_addr;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
-  (const ACE_PEER_ACCEPTOR_ADDR &addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Strategy_Acceptor
+  (const typename PEER_ACCEPTOR::PEER_ADDR &addr,
    ACE_Reactor *reactor,
    ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
-   ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> *acc_s,
+   ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> *acc_s,
    ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
    ACE_Scheduling_Strategy<SVC_HANDLER> *sch_s,
    const ACE_TCHAR service_name[],
@@ -689,7 +690,7 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
       service_name_ (0),
       service_description_ (0)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Strategy_Acceptor");
 
   if (this->open (addr,
                   reactor,
@@ -709,11 +710,11 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
 // Perform termination activities when <this> is removed from the
 // <ACE_Reactor>.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close (ACE_HANDLE,
                                                                        ACE_Reactor_Mask)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close");
   // Guard against multiple closes.
   if (this->reactor () != 0)
     {
@@ -761,10 +762,10 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDL
 // creating subclass instances of <SVC_HANDLER>, using a singleton,
 // dynamically linking the handler, etc.).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::make_svc_handler (SVC_HANDLER *&sh)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::make_svc_handler");
   return this->creation_strategy_->make_svc_handler (sh);
 }
 
@@ -772,11 +773,11 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_H
 // <svc_handler>.  The default behavior delegates to the
 // <Strategy_Acceptor::accept> in the Acceptor_Strategy.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept_svc_handler
   (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept_svc_handler");
   return this->accept_strategy_->accept_svc_handler (svc_handler);
 }
 
@@ -788,20 +789,20 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
 // concurrency activations (such as creating the SVC_HANDLER as an
 // "active object" via multi-threading or multi-processing).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler
   (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler");
   return this->concurrency_strategy_->activate_svc_handler
     (svc_handler,
      (void *) this);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Strategy_Acceptor (void)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor");
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Strategy_Acceptor");
   ACE_OS::free ((void *) this->service_name_);
   ACE_OS::free ((void *) this->service_description_);
   this->handle_close ();
@@ -809,22 +810,22 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor
 
 // Signal the server to shutdown gracefully.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_signal (int, siginfo_t *, ucontext_t *)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_signal (int, siginfo_t *, ucontext_t *)
 {
   ACE_Reactor::instance()->end_reactor_event_loop ();
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::info (ACE_TCHAR **strp,
                                                                size_t length) const
 {
   ACE_TRACE ("ACE_Strategy_Acceptor::info");
 
   ACE_TCHAR buf[BUFSIZ];
   ACE_TCHAR service_addr_str[BUFSIZ];
-  ACE_PEER_ACCEPTOR_ADDR addr;
+  typename PEER_ACCEPTOR::PEER_ADDR addr;
 
   if (this->acceptor ().get_local_addr (addr) == -1)
     return -1;
@@ -850,20 +851,20 @@ ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
   return static_cast<int> (ACE_OS::strlen (buf));
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini (void)
 {
-  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
-  return this->ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close ();
+  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini");
+  return this->ACE_Strategy_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close ();
 }
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Oneshot_Acceptor)
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> void
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::dump");
 
   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nsvc_handler_ = %x"), this->svc_handler_));
@@ -876,13 +877,13 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
-  (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open
+  (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
    ACE_Reactor *reactor,
    ACE_Concurrency_Strategy<SVC_HANDLER> *con_s)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::open");
   this->reactor (reactor);
 
   // Initialize the concurrency strategy.
@@ -900,20 +901,20 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
   return this->peer_acceptor_.open (local_addr, 1);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Oneshot_Acceptor (void)
   : svc_handler_ (0),
     restart_ (false),
     concurrency_strategy_ (0),
     delete_concurrency_strategy_ (false)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Oneshot_Acceptor");
   this->reactor (0);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor
-  (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Oneshot_Acceptor
+  (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
    ACE_Reactor *reactor,
    ACE_Concurrency_Strategy<SVC_HANDLER> *cs)
     : svc_handler_ (0),
@@ -921,32 +922,32 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor
       concurrency_strategy_ (0),
       delete_concurrency_strategy_ (false)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::ACE_Oneshot_Acceptor");
   if (this->open (local_addr, reactor, cs) == -1)
     ACELIB_ERROR ((LM_ERROR,
                 ACE_TEXT ("%p\n"),
                 ACE_TEXT ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor")));
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Oneshot_Acceptor (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Oneshot_Acceptor (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Oneshot_Acceptor");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::~ACE_Oneshot_Acceptor");
   this->handle_close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::close (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::close");
   return this->handle_close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close (ACE_HANDLE,
                                                                       ACE_Reactor_Mask)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_close");
 
   // Guard against multiple closes.
   if (this->delete_concurrency_strategy_)
@@ -969,12 +970,12 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_timeout
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_timeout
   (const ACE_Time_Value &tv,
    const void *arg)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_timeout");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_timeout");
   errno = ETIME;
 
   if (this->svc_handler_->handle_timeout (tv, arg) == -1)
@@ -989,20 +990,20 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_timeout
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::cancel (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::cancel (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::cancel");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::cancel");
   return this->reactor () && this->reactor ()->cancel_timer (this);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::register_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::register_handler
   (SVC_HANDLER *svc_handler,
    const ACE_Synch_Options &synch_options,
    bool restart)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::register_handler");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::register_handler");
   // Can't do this if we don't have a Reactor.
   if (this->reactor () == 0)
     {
@@ -1035,11 +1036,11 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::register_handler
 // concurrency activations (such as creating the SVC_HANDLER as an
 // "active object" via multi-threading or multi-processing).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler
   (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::activate_svc_handler");
   return this->concurrency_strategy_->activate_svc_handler
     (svc_handler,
      (void *) this);
@@ -1048,15 +1049,15 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
 // Factors out the code shared between the <accept> and <handle_input>
 // methods.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::shared_accept
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::shared_accept
   (SVC_HANDLER *svc_handler,
-   ACE_PEER_ACCEPTOR_ADDR *remote_addr,
+   typename PEER_ACCEPTOR::PEER_ADDR *remote_addr,
    ACE_Time_Value *timeout,
    bool restart,
    bool reset_new_handle)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::shared_accept");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::shared_accept");
   if (svc_handler == 0)
     return -1;
 
@@ -1085,15 +1086,15 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::shared_accept
 // then activate the SVC_HANDLER.  Note that SVC_HANDLER::open()
 // decides what type of concurrency strategy to use.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept
   (SVC_HANDLER *svc_handler,
-   ACE_PEER_ACCEPTOR_ADDR *remote_addr,
+   typename PEER_ACCEPTOR::PEER_ADDR *remote_addr,
    const ACE_Synch_Options &synch_options,
    bool restart,
    bool reset_new_handle)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::accept");
   // Note that if timeout == ACE_Time_Value (x, y) where (x > 0 || y >
   // 0) then this->connector_.connect() will block synchronously.  If
   // <use_reactor> is set then we don't want this to happen (since we
@@ -1130,10 +1131,10 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept
 // Accepts one pending connection from a client (since we're the
 // "oneshot" Acceptor).
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_input (ACE_HANDLE)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::handle_input");
   int result = 0;
 
   // Cancel any timer that might be pending.
@@ -1172,28 +1173,28 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE
 
 // Hook called by the explicit dynamic linking facility.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init (int, ACE_TCHAR *[])
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::init (int, ACE_TCHAR *[])
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::init");
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::fini");
   return this->handle_close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
-                                                              size_t length) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::info (ACE_TCHAR **strp,
+                                                        size_t length) const
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::info");
   ACE_TCHAR buf[BUFSIZ];
   ACE_TCHAR addr_str[BUFSIZ];
-  ACE_PEER_ACCEPTOR_ADDR addr;
+  typename PEER_ACCEPTOR::PEER_ADDR addr;
 
   if (this->peer_acceptor_.get_local_addr (addr) == -1)
     return -1;
@@ -1213,41 +1214,41 @@ ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
   return static_cast<int> (ACE_OS::strlen (buf));
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::suspend");
   return this->reactor () && this->reactor ()->suspend_handler (this);
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> int
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume (void)
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::resume");
   return this->reactor () && this->reactor ()->resume_handler (this);
 }
 
 // Returns ACE_HANDLE of the underlying peer_acceptor.
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> ACE_HANDLE
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle (void) const
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::get_handle");
   return this->peer_acceptor_.get_handle ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR> PEER_ACCEPTOR &
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor (void) const
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
-  return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::acceptor");
+  return (PEER_ACCEPTOR &) this->peer_acceptor_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
-ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
+ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR & () const
 {
-  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
-  return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
+  ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, PEER_ACCEPTOR>::operator PEER_ACCEPTOR &");
+  return (PEER_ACCEPTOR &) this->peer_acceptor_;
 }
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ACE/ace/Acceptor.h b/ACE/ace/Acceptor.h
index b673015bb84..e0114d4a437 100644
--- a/ACE/ace/Acceptor.h
+++ b/ACE/ace/Acceptor.h
@@ -49,15 +49,15 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * strategies can be overridden by subclasses individually or as
  * a group.
  */
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
 class ACE_Acceptor : public ACE_Service_Object
 {
 public:
 
   // Useful STL-style traits.
-  typedef ACE_PEER_ACCEPTOR_ADDR            addr_type;
-  typedef ACE_PEER_ACCEPTOR                 acceptor_type;
-  typedef SVC_HANDLER                       handler_type;
+  typedef typename PEER_ACCEPTOR::PEER_ADDR addr_type;
+  typedef PEER_ACCEPTOR acceptor_type;
+  typedef SVC_HANDLER handler_type;
   typedef typename SVC_HANDLER::stream_type stream_type;
 
   /// "Do-nothing" constructor.
@@ -97,7 +97,7 @@ public:
    *                   @p local_addr.  Generally used to request that the
    *                   OS allow reuse of the listen port.  The default is 1.
    */
-  ACE_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+  ACE_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
                 ACE_Reactor *reactor = ACE_Reactor::instance (),
                 int flags = 0,
                 int use_select = 1,
@@ -139,7 +139,7 @@ public:
    * @retval 0  Success
    * @retval -1 Failure, @c errno contains an error code.
    */
-  virtual int open (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+  virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
                     ACE_Reactor *reactor = ACE_Reactor::instance (),
                     int flags = 0,
                     int use_select = 1,
@@ -149,10 +149,10 @@ public:
   virtual ~ACE_Acceptor (void);
 
   /// Return the underlying PEER_ACCEPTOR object.
-  virtual operator ACE_PEER_ACCEPTOR &() const;
+  virtual operator PEER_ACCEPTOR &() const;
 
   /// Return the underlying PEER_ACCEPTOR object.
-  virtual ACE_PEER_ACCEPTOR &acceptor (void) const;
+  virtual PEER_ACCEPTOR &acceptor (void) const;
 
   /// Returns the listening acceptor's {ACE_HANDLE}.
   virtual ACE_HANDLE get_handle (void) const;
@@ -235,10 +235,10 @@ public:
 
 protected:
   /// Concrete factory for accepting connections from clients...
-  ACE_PEER_ACCEPTOR peer_acceptor_;
+  PEER_ACCEPTOR peer_acceptor_;
 
   /// Needed to reopen the socket if {accept} fails.
-  ACE_PEER_ACCEPTOR_ADDR peer_acceptor_addr_;
+  typename PEER_ACCEPTOR::PEER_ADDR peer_acceptor_addr_;
 
   /**
    * Flags that indicate how {SVC_HANDLER}'s should be initialized
@@ -270,26 +270,26 @@ protected:
  * SVC_HANDLER, and (3) activating the SVC_HANDLER with a
  * particular concurrency mechanism.
  */
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
 class ACE_Strategy_Acceptor
-  : public ACE_Acceptor <SVC_HANDLER, ACE_PEER_ACCEPTOR_2>
+  : public ACE_Acceptor <SVC_HANDLER, PEER_ACCEPTOR>
 {
 public:
 
   // Useful STL-style traits.
   typedef ACE_Creation_Strategy<SVC_HANDLER>
           creation_strategy_type;
-  typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>
+  typedef ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR>
           accept_strategy_type;
   typedef ACE_Concurrency_Strategy<SVC_HANDLER>
           concurrency_strategy_type;
   typedef ACE_Scheduling_Strategy<SVC_HANDLER> scheduling_strategy_type;
-  typedef ACE_Acceptor <SVC_HANDLER, ACE_PEER_ACCEPTOR_2>
+  typedef ACE_Acceptor <SVC_HANDLER, PEER_ACCEPTOR>
           base_type;
 
   // = Define some useful (old style) traits.
   typedef ACE_Creation_Strategy<SVC_HANDLER> CREATION_STRATEGY;
-  typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACCEPT_STRATEGY;
+  typedef ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> ACCEPT_STRATEGY;
   typedef ACE_Concurrency_Strategy<SVC_HANDLER> CONCURRENCY_STRATEGY;
   typedef ACE_Scheduling_Strategy<SVC_HANDLER> SCHEDULING_STRATEGY;
 
@@ -305,10 +305,10 @@ public:
    * with the Reactor and listen for connection requests at the
    * designated {local_addr}.
    */
-  ACE_Strategy_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+  ACE_Strategy_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
                          ACE_Reactor * = ACE_Reactor::instance (),
                          ACE_Creation_Strategy<SVC_HANDLER> * = 0,
-                         ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> * = 0,
+                         ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> * = 0,
                          ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
                          ACE_Scheduling_Strategy<SVC_HANDLER> * = 0,
                          const ACE_TCHAR service_name[] = 0,
@@ -350,7 +350,7 @@ public:
    * @retval 0  Success
    * @retval -1 Failure, @c errno contains an error code.
    */
-  virtual int open (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+  virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
                     ACE_Reactor *reactor,
                     int flags = 0,
                     int use_select = 1,
@@ -362,10 +362,10 @@ public:
    * with the Reactor and listen for connection requests at the
    * designated {local_addr}.
    */
-  virtual int open (const ACE_PEER_ACCEPTOR_ADDR &,
+  virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &,
                     ACE_Reactor * = ACE_Reactor::instance (),
                     ACE_Creation_Strategy<SVC_HANDLER> * = 0,
-                    ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> * =0,
+                    ACE_Accept_Strategy<SVC_HANDLER, PEER_ACCEPTOR> * =0,
                     ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
                     ACE_Scheduling_Strategy<SVC_HANDLER> * = 0,
                     const ACE_TCHAR *service_name = 0,
@@ -377,10 +377,10 @@ public:
   virtual ~ACE_Strategy_Acceptor (void);
 
   /// Return the underlying PEER_ACCEPTOR object.
-  virtual operator ACE_PEER_ACCEPTOR &() const;
+  virtual operator PEER_ACCEPTOR &() const;
 
   /// Return the underlying PEER_ACCEPTOR object.
-  virtual ACE_PEER_ACCEPTOR &acceptor (void) const;
+  virtual PEER_ACCEPTOR &acceptor (void) const;
 
   /// Returns the listening acceptor's {ACE_HANDLE}.
   virtual ACE_HANDLE get_handle (void) const;
@@ -496,7 +496,7 @@ protected:
 
   /// Address that the {Strategy_Acceptor} uses to listen for
   /// connections.
-  ACE_PEER_ACCEPTOR_ADDR service_addr_;
+  typename PEER_ACCEPTOR::PEER_ADDR service_addr_;
 };
 
 /**
@@ -528,15 +528,15 @@ protected:
  *    immediately. If there is no immediately available connection to accept,
  *    behavior is governed by the ACE_Synch_Options argument passed to open().
  */
-template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
+template <typename SVC_HANDLER, typename PEER_ACCEPTOR>
 class ACE_Oneshot_Acceptor : public ACE_Service_Object
 {
 public:
 
   // Useful STL-style traits.
-  typedef ACE_PEER_ACCEPTOR_ADDR            addr_type;
-  typedef ACE_PEER_ACCEPTOR                 acceptor_type;
-  typedef SVC_HANDLER                       handler_type;
+  typedef typename PEER_ACCEPTOR::PEER_ADDR addr_type;
+  typedef PEER_ACCEPTOR acceptor_type;
+  typedef SVC_HANDLER handler_type;
   typedef typename SVC_HANDLER::stream_type stream_type;
 
   /// Constructor.
@@ -550,7 +550,7 @@ public:
    * this point -- the @a reactor parameter is saved in case it's
    * needed later.
    */
-  ACE_Oneshot_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
+  ACE_Oneshot_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr,
                         ACE_Reactor *reactor = ACE_Reactor::instance (),
                         ACE_Concurrency_Strategy<SVC_HANDLER> * = 0);
 
@@ -562,7 +562,7 @@ public:
    * this point -- the @a reactor parameter is saved in case it's
    * needed later.
    */
-  int open (const ACE_PEER_ACCEPTOR_ADDR &,
+  int open (const typename PEER_ACCEPTOR::PEER_ADDR &,
             ACE_Reactor *reactor = ACE_Reactor::instance (),
             ACE_Concurrency_Strategy<SVC_HANDLER> * = 0);
 
@@ -573,7 +573,7 @@ public:
   /// Create a {SVC_HANDLER}, accept the connection into the
   /// {SVC_HANDLER}, and activate the {SVC_HANDLER}.
   virtual int accept (SVC_HANDLER * = 0,
-                      ACE_PEER_ACCEPTOR_ADDR *remote_addr = 0,
+                      typename PEER_ACCEPTOR::PEER_ADDR *remote_addr = 0,
                       const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
                       bool restart = true,
                       bool reset_new_handle = false);
@@ -582,10 +582,10 @@ public:
   virtual int cancel (void);
 
   /// Return the underlying {PEER_ACCEPTOR} object.
-  virtual operator ACE_PEER_ACCEPTOR &() const;
+  virtual operator PEER_ACCEPTOR &() const;
 
   /// Return the underlying {PEER_ACCEPTOR} object.
-  virtual ACE_PEER_ACCEPTOR &acceptor (void) const;
+  virtual PEER_ACCEPTOR &acceptor (void) const;
 
   /// Close down the {Oneshot_Acceptor}.
   virtual int close (void);
@@ -610,7 +610,7 @@ protected:
   /// Factors out the code shared between the {accept} and
   /// {handle_input} methods.
   int shared_accept (SVC_HANDLER *svc_handler,
-                     ACE_PEER_ACCEPTOR_ADDR *remote_addr,
+                     typename PEER_ACCEPTOR::PEER_ADDR *remote_addr,
                      ACE_Time_Value *timeout,
                      bool restart,
                      bool reset_new_handle);
@@ -670,7 +670,7 @@ private:
   bool restart_;
 
   /// Factory that establishes connections passively.
-  ACE_PEER_ACCEPTOR peer_acceptor_;
+  PEER_ACCEPTOR peer_acceptor_;
 
   /// Concurrency strategy for an Acceptor.
   ACE_Concurrency_Strategy<SVC_HANDLER> *concurrency_strategy_;
diff --git a/ACE/ace/Connector.cpp b/ACE/ace/Connector.cpp
index 970739aac2c..c0415faf56e 100644
--- a/ACE/ace/Connector.cpp
+++ b/ACE/ace/Connector.cpp
@@ -17,15 +17,14 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Connector)
 
-template <class SVC_HANDLER>
-ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler
-(ACE_Connector_Base<SVC_HANDLER> &connector,
- SVC_HANDLER *sh,
- long id)
-  : connector_ (connector)
-  , svc_handler_ (sh)
-  , cleanup_svc_handler_ (0)
-  , timer_id_ (id)
+template <typename SVC_HANDLER>
+ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler (ACE_Connector_Base<SVC_HANDLER> &connector,
+                                                                               SVC_HANDLER *sh,
+                                                                               long id)
+  : connector_ (connector),
+    svc_handler_ (sh),
+    cleanup_svc_handler_ (0),
+    timer_id_ (id)
 {
   ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler");
 
@@ -44,37 +43,35 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler
     }
 }
 
-template <class SVC_HANDLER>
+template <typename SVC_HANDLER>
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::~ACE_NonBlocking_Connect_Handler (void)
 {
   if (this->cleanup_svc_handler_)
-    {
-      this->cleanup_svc_handler_->remove_reference ();
-    }
+    this->cleanup_svc_handler_->remove_reference ();
 }
 
-template <class SVC_HANDLER> SVC_HANDLER *
+template <typename SVC_HANDLER> SVC_HANDLER *
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::svc_handler (void)
 {
   ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::svc_handler");
   return this->svc_handler_;
 }
 
-template <class SVC_HANDLER> long
+template <typename SVC_HANDLER> long
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id (void)
 {
   ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id");
   return this->timer_id_;
 }
 
-template <class SVC_HANDLER> void
+template <typename SVC_HANDLER> void
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id (long id)
 {
   ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id");
   this->timer_id_ = id;
 }
 
-template <class SVC_HANDLER> void
+template <typename SVC_HANDLER> void
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
@@ -87,7 +84,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class SVC_HANDLER> bool
+template <typename SVC_HANDLER> bool
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::close (SVC_HANDLER *&sh)
 {
   // Make sure that we haven't already initialized the Svc_Handler.
@@ -131,7 +128,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::close (SVC_HANDLER *&sh)
 }
 
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_timeout
 (const ACE_Time_Value &tv,
  const void *arg)
@@ -154,7 +151,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_timeout
 }
 
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input (ACE_HANDLE)
 {
   // Called when a failure occurs during asynchronous connection
@@ -173,7 +170,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input (ACE_HANDLE)
   return retval;
 }
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_close (ACE_HANDLE handle,
                                                             ACE_Reactor_Mask m)
 {
@@ -187,7 +184,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_close (ACE_HANDLE handle,
   return -1;
 }
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_output (ACE_HANDLE handle)
 {
   // Called when a connection is establishment asynchronous.
@@ -206,7 +203,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_output (ACE_HANDLE handle)
   return retval;
 }
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_exception (ACE_HANDLE h)
 {
   // On Win32, the except mask must also be set for asynchronous
@@ -215,17 +212,17 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_exception (ACE_HANDLE h)
   return this->handle_output (h);
 }
 
-template <class SVC_HANDLER> int
+template <typename SVC_HANDLER> int
 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::resume_handler (void)
 {
   return ACE_Event_Handler::ACE_EVENT_HANDLER_NOT_RESUMED;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> void
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::dump");
 
   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nflags_ = %d"), this->flags_));
@@ -233,10 +230,10 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::make_svc_handler (SVC_HANDLER *&sh)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::make_svc_handler");
 
   if (sh == 0)
     ACE_NEW_RETURN (sh,
@@ -249,10 +246,10 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler (SVC_HANDLER
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler (SVC_HANDLER *svc_handler)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::activate_svc_handler (SVC_HANDLER *svc_handler)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::activate_svc_handler");
   // No errors initially
   int error = 0;
 
@@ -281,23 +278,23 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler (SVC_HAND
     return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_PEER_CONNECTOR &
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> PEER_CONNECTOR &
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connector (void) const
 {
-  return const_cast<ACE_PEER_CONNECTOR &> (this->connector_);
+  return const_cast<PEER_CONNECTOR &> (this->connector_);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler
 (SVC_HANDLER *&svc_handler,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  ACE_Time_Value *timeout,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler");
 
   return this->connector_.connect (svc_handler->peer (),
                                    remote_addr,
@@ -308,18 +305,18 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
                                    perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler
 (SVC_HANDLER *&svc_handler,
  SVC_HANDLER *&sh_copy,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  ACE_Time_Value *timeout,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler");
 
   sh_copy = svc_handler;
   return this->connector_.connect (svc_handler->peer (),
@@ -331,29 +328,29 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
                                    perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open (ACE_Reactor *r, int flags)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::open (ACE_Reactor *r, int flags)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::open");
   this->reactor (r);
   this->flags_ = flags;
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connector (ACE_Reactor *r,
+template <typename SVC_HANDLER, typename PEER_CONNECTOR>
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::ACE_Connector (ACE_Reactor *r,
                                                                  int flags)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connector");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::ACE_Connector");
   (void) this->open (r, flags);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect
 (SVC_HANDLER *&sh,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  const ACE_Synch_Options &synch_options,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
@@ -369,13 +366,13 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
                           perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect
 (SVC_HANDLER *&sh,
  SVC_HANDLER *&sh_copy,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  const ACE_Synch_Options &synch_options,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
@@ -391,18 +388,18 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
                           perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_i
 (SVC_HANDLER *&sh,
  SVC_HANDLER **sh_copy,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  const ACE_Synch_Options &synch_options,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_i");
 
   // If the user hasn't supplied us with a <SVC_HANDLER> we'll use the
   // factory method to create one.  Otherwise, things will remain as
@@ -481,11 +478,11 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_n
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_n
 (size_t n,
  SVC_HANDLER *sh[],
- ACE_PEER_CONNECTOR_ADDR remote_addrs[],
+ typename PEER_CONNECTOR::PEER_ADDR remote_addrs[],
  ACE_TCHAR *failed_svc_handlers,
  const ACE_Synch_Options &synch_options)
 {
@@ -511,10 +508,10 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_n
 }
 
 // Cancel a <svc_handler> that was started asynchronously.
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::cancel (SVC_HANDLER *sh)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::cancel (SVC_HANDLER *sh)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::cancel");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::cancel");
 
   ACE_Event_Handler *handler =
     this->reactor ()->find_handler (sh->get_handle ());
@@ -539,12 +536,12 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::cancel (SVC_HANDLER *sh)
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::nonblocking_connect
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::nonblocking_connect
 (SVC_HANDLER *sh,
  const ACE_Synch_Options &synch_options)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::nonblocking_connect");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::nonblocking_connect");
 
   // Must have a valid Reactor for non-blocking connects to work.
   if (this->reactor () == 0)
@@ -617,16 +614,16 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::nonblocking_connect
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connector (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR>
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::~ACE_Connector (void)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connector");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::~ACE_Connector");
 
   this->close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::initialize_svc_handler
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> void
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::initialize_svc_handler
 (ACE_HANDLE handle,
  SVC_HANDLER *svc_handler)
 {
@@ -641,7 +638,7 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::initialize_svc_handler
   // Transfer ownership of the ACE_HANDLE to the SVC_HANDLER.
   svc_handler->set_handle (handle);
 
-  ACE_PEER_CONNECTOR_ADDR raddr;
+  typename PEER_CONNECTOR::PEER_ADDR raddr;
 
   // Check to see if we're connected.
   if (svc_handler->peer ().get_remote_addr (raddr) != -1)
@@ -662,26 +659,26 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::initialize_svc_handler
     }
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::reactor (ACE_Reactor *reactor)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> void
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::reactor (ACE_Reactor *reactor)
 {
   this->reactor_ = reactor;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Reactor *
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::reactor (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> ACE_Reactor *
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::reactor (void) const
 {
   return this->reactor_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Unbounded_Set<ACE_HANDLE> &
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::non_blocking_handles (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> ACE_Unbounded_Set<ACE_HANDLE> &
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::non_blocking_handles (void)
 {
   return this->non_blocking_handles_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::close (void)
 {
   // If there are no non-blocking handle pending, return immediately.
   if (this->non_blocking_handles ().size () == 0)
@@ -739,41 +736,41 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::fini (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::fini (void)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::fini");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::fini");
 
   return this->close ();
 }
 
 // Hook called by the explicit dynamic linking facility.
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::init (int, ACE_TCHAR *[])
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::init (int, ACE_TCHAR *[])
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::init");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::init");
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::suspend (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::suspend (void)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::suspend");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::suspend");
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::resume (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::resume (void)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::resume");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::resume");
   return -1;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::info (ACE_TCHAR **strp, size_t length) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::info (ACE_TCHAR **strp, size_t length) const
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::info");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::info");
   ACE_TCHAR buf[BUFSIZ];
 
   ACE_OS::sprintf (buf,
@@ -788,23 +785,23 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::info (ACE_TCHAR **strp, size_t
   return static_cast<int> (ACE_OS::strlen (buf));
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open (ACE_Reactor *r,
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::open (ACE_Reactor *r,
                                                                  int flags)
 {
-  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
+  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::open");
   return this->open (r, 0, 0, 0, flags);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::open
 (ACE_Reactor *r,
  ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
- ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *conn_s,
+ ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> *conn_s,
  ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
  int flags)
 {
-  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
+  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::open");
 
   this->reactor (r);
 
@@ -880,11 +877,11 @@ ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open
   return 0;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Strategy_Connector
+template <typename SVC_HANDLER, typename PEER_CONNECTOR>
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::ACE_Strategy_Connector
 (ACE_Reactor *reactor,
  ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
- ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *conn_s,
+ ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> *conn_s,
  ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
  int flags)
   : base_type (reactor),
@@ -895,23 +892,23 @@ ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Strategy_Connecto
     concurrency_strategy_ (0),
     delete_concurrency_strategy_ (false)
 {
-  ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Strategy_Connector");
+  ACE_TRACE ("ACE_Connector<SVC_HANDLER, PEER_CONNECTOR>::ACE_Strategy_Connector");
 
   if (this->open (reactor, cre_s, conn_s, con_s, flags) == -1)
     ACELIB_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Strategy_Connector::ACE_Strategy_Connector")));
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Strategy_Connector (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR>
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::~ACE_Strategy_Connector (void)
 {
-  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Strategy_Connector");
+  ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::~ACE_Strategy_Connector");
 
   // Close down
   this->close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::close (void)
 {
   if (this->delete_creation_strategy_)
     delete this->creation_strategy_;
@@ -931,18 +928,18 @@ ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
   return SUPER::close ();
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::make_svc_handler (SVC_HANDLER *&sh)
 {
   return this->creation_strategy_->make_svc_handler (sh);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler
 (SVC_HANDLER *&sh,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  ACE_Time_Value *timeout,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
@@ -956,13 +953,13 @@ ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
                                                        perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_svc_handler
 (SVC_HANDLER *&sh,
  SVC_HANDLER *&sh_copy,
- const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
  ACE_Time_Value *timeout,
- const ACE_PEER_CONNECTOR_ADDR &local_addr,
+ const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
  int reuse_addr,
  int flags,
  int perms)
@@ -977,26 +974,26 @@ ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
                                                        perms);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler (SVC_HANDLER *svc_handler)
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> int
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::activate_svc_handler (SVC_HANDLER *svc_handler)
 {
   return this->concurrency_strategy_->activate_svc_handler (svc_handler, this);
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Creation_Strategy<SVC_HANDLER> *
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::creation_strategy (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> ACE_Creation_Strategy<SVC_HANDLER> *
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::creation_strategy (void) const
 {
   return this->creation_strategy_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_strategy (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> *
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::connect_strategy (void) const
 {
   return this->connect_strategy_;
 }
 
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Concurrency_Strategy<SVC_HANDLER> *
-ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::concurrency_strategy (void) const
+template <typename SVC_HANDLER, typename PEER_CONNECTOR> ACE_Concurrency_Strategy<SVC_HANDLER> *
+ACE_Strategy_Connector<SVC_HANDLER, PEER_CONNECTOR>::concurrency_strategy (void) const
 {
   return this->concurrency_strategy_;
 }
diff --git a/ACE/ace/Connector.h b/ACE/ace/Connector.h
index 0063d9498b8..dba2862908c 100644
--- a/ACE/ace/Connector.h
+++ b/ACE/ace/Connector.h
@@ -155,18 +155,18 @@ private:
  * service.  Both blocking and non-blocking connects are supported.
  * Further, non-blocking connects support timeouts.
  */
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
+template <typename SVC_HANDLER, typename PEER_CONNECTOR>
 class ACE_Connector : public ACE_Connector_Base<SVC_HANDLER>, public ACE_Service_Object
 {
 public:
 
   // Useful STL-style traits.
-  typedef typename SVC_HANDLER::addr_type        addr_type;
-  typedef ACE_PEER_CONNECTOR                     connector_type;
-  typedef SVC_HANDLER                            handler_type;
-  typedef typename SVC_HANDLER::stream_type      stream_type;
-  typedef typename ACE_PEER_CONNECTOR::PEER_ADDR peer_addr_type;
-  typedef ACE_PEER_CONNECTOR_ADDR                ACE_PEER_ADDR_TYPEDEF;
+  typedef typename SVC_HANDLER::addr_type addr_type;
+  typedef PEER_CONNECTOR connector_type;
+  typedef SVC_HANDLER handler_type;
+  typedef typename SVC_HANDLER::stream_type stream_type;
+  typedef typename PEER_CONNECTOR::PEER_ADDR peer_addr_type;
+  typedef typename PEER_CONNECTOR::PEER_ADDR PEER_ADDR_TYPEDEF;
 
   /**
    * Initialize a connector.  @a flags indicates how SVC_HANDLER's
@@ -203,10 +203,10 @@ public:
    * automatically to prevent resource leaks.
    */
   virtual int connect (SVC_HANDLER *&svc_handler,
-                       const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                       const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                        const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
-                       const ACE_PEER_CONNECTOR_ADDR &local_addr
-                       = (peer_addr_type &) ACE_PEER_CONNECTOR_ADDR_ANY,
+                       const typename PEER_CONNECTOR::PEER_ADDR &local_addr 
+                         = (peer_addr_type &) peer_addr_type::sap_any,
                        int reuse_addr = 0,
                        int flags = O_RDWR,
                        int perms = 0);
@@ -223,10 +223,10 @@ public:
    */
   virtual int connect (SVC_HANDLER *&svc_handler_hint,
                        SVC_HANDLER *&svc_handler,
-                       const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                       const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                        const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
-                       const ACE_PEER_CONNECTOR_ADDR &local_addr
-                       = (peer_addr_type &) ACE_PEER_CONNECTOR_ADDR_ANY,
+                       const typename PEER_CONNECTOR::PEER_ADDR &local_addr
+                         = (peer_addr_type &) peer_addr_type::sap_any,
                        int reuse_addr = 0,
                        int flags = O_RDWR,
                        int perms = 0);
@@ -241,7 +241,7 @@ public:
    */
   virtual int connect_n (size_t n,
                          SVC_HANDLER *svc_handlers[],
-                         ACE_PEER_CONNECTOR_ADDR remote_addrs[],
+                         typename PEER_CONNECTOR::PEER_ADDR remote_addrs[],
                          ACE_TCHAR *failed_svc_handlers = 0,
                          const ACE_Synch_Options &synch_options =
                          ACE_Synch_Options::defaults);
@@ -259,7 +259,7 @@ public:
   virtual int close (void);
 
   /// Return the underlying PEER_CONNECTOR object.
-  virtual ACE_PEER_CONNECTOR &connector (void) const;
+  virtual PEER_CONNECTOR &connector (void) const;
 
   /// Initialize Svc_Handler.
   virtual void initialize_svc_handler (ACE_HANDLE handle,
@@ -301,17 +301,17 @@ protected:
    * <PEER_CONNECTOR::connect>.
    */
   virtual int connect_svc_handler (SVC_HANDLER *&svc_handler,
-                                   const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                                    ACE_Time_Value *timeout,
-                                   const ACE_PEER_CONNECTOR_ADDR &local_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
                                    int reuse_addr,
                                    int flags,
                                    int perms);
   virtual int connect_svc_handler (SVC_HANDLER *&svc_handler,
                                    SVC_HANDLER *&sh_copy,
-                                   const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                                    ACE_Time_Value *timeout,
-                                   const ACE_PEER_CONNECTOR_ADDR &local_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
                                    int reuse_addr,
                                    int flags,
                                    int perms);
@@ -335,9 +335,9 @@ protected:
   /// Implementation of the connect methods.
   virtual int connect_i (SVC_HANDLER *&svc_handler,
                          SVC_HANDLER **sh_copy,
-                         const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                         const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                          const ACE_Synch_Options &synch_options,
-                         const ACE_PEER_CONNECTOR_ADDR &local_addr,
+                         const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
                          int reuse_addr,
                          int flags,
                          int perms);
@@ -368,7 +368,7 @@ protected:
 
 private:
   /// This is the peer connector factory.
-  ACE_PEER_CONNECTOR connector_;
+  PEER_CONNECTOR connector_;
 
   /**
    * Flags that indicate how SVC_HANDLER's should be initialized
@@ -400,30 +400,30 @@ private:
  * and (3) activating the SVC_HANDLER with a
  * particular concurrency mechanism after the connection is established.
  */
-template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
+template <class SVC_HANDLER, typename PEER_CONNECTOR>
 class ACE_Strategy_Connector
-  : public ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+  : public ACE_Connector <SVC_HANDLER, PEER_CONNECTOR>
 {
 public:
 
   // Useful STL-style traits.
   typedef ACE_Creation_Strategy<SVC_HANDLER>
   creation_strategy_type;
-  typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+  typedef ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR>
   connect_strategy_type;
   typedef ACE_Concurrency_Strategy<SVC_HANDLER>
   concurrency_strategy_type;
-  typedef ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+  typedef ACE_Connector <SVC_HANDLER, PEER_CONNECTOR>
   base_type;
 
   // = Define some useful (old style) traits.
   typedef ACE_Creation_Strategy<SVC_HANDLER>
   CREATION_STRATEGY;
-  typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+  typedef ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR>
   CONNECT_STRATEGY;
   typedef ACE_Concurrency_Strategy<SVC_HANDLER>
   CONCURRENCY_STRATEGY;
-  typedef ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+  typedef ACE_Connector <SVC_HANDLER, PEER_CONNECTOR>
   SUPER;
 
   /**
@@ -434,7 +434,7 @@ public:
    */
   ACE_Strategy_Connector (ACE_Reactor *r = ACE_Reactor::instance (),
                           ACE_Creation_Strategy<SVC_HANDLER> * = 0,
-                          ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> * = 0,
+                          ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> * = 0,
                           ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
                           int flags = 0);
 
@@ -456,7 +456,7 @@ public:
    */
   virtual int open (ACE_Reactor *r = ACE_Reactor::instance (),
                     ACE_Creation_Strategy<SVC_HANDLER> * = 0,
-                    ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> * = 0,
+                    ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> * = 0,
                     ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
                     int flags = 0);
 
@@ -468,7 +468,7 @@ public:
 
   // = Strategies accessors
   virtual ACE_Creation_Strategy<SVC_HANDLER> *creation_strategy (void) const;
-  virtual ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *connect_strategy (void) const;
+  virtual ACE_Connect_Strategy<SVC_HANDLER, PEER_CONNECTOR> *connect_strategy (void) const;
   virtual ACE_Concurrency_Strategy<SVC_HANDLER> *concurrency_strategy (void) const;
 
 protected:
@@ -495,9 +495,9 @@ protected:
    * <PEER_CONNECTOR::connect> in the <Connect_Strategy>.
    */
   virtual int connect_svc_handler (SVC_HANDLER *&sh,
-                                   const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                                    ACE_Time_Value *timeout,
-                                   const ACE_PEER_CONNECTOR_ADDR &local_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
                                    int reuse_addr,
                                    int flags,
                                    int perms);
@@ -514,9 +514,9 @@ protected:
    */
   virtual int connect_svc_handler (SVC_HANDLER *&sh,
                                    SVC_HANDLER *&sh_copy,
-                                   const ACE_PEER_CONNECTOR_ADDR &remote_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &remote_addr,
                                    ACE_Time_Value *timeout,
-                                   const ACE_PEER_CONNECTOR_ADDR &local_addr,
+                                   const typename PEER_CONNECTOR::PEER_ADDR &local_addr,
                                    int reuse_addr,
                                    int flags,
                                    int perms);
diff --git a/ACE/ace/Global_Macros.h b/ACE/ace/Global_Macros.h
index cf24327650b..447e997d5f8 100644
--- a/ACE/ace/Global_Macros.h
+++ b/ACE/ace/Global_Macros.h
@@ -948,32 +948,35 @@ ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (AC
 #endif /* ACE_WIN32 */
 
 // Handle ACE_Message_Queue.
-#   define ACE_SYNCH_DECL class _ACE_SYNCH
+#   define ACE_SYNCH_DECL typename _ACE_SYNCH
 #   define ACE_SYNCH_USE _ACE_SYNCH
 #   define ACE_SYNCH_MUTEX_T typename _ACE_SYNCH::MUTEX
 #   define ACE_SYNCH_CONDITION_T typename _ACE_SYNCH::CONDITION
 #   define ACE_SYNCH_SEMAPHORE_T typename _ACE_SYNCH::SEMAPHORE
 
 // Handle ACE_Malloc*
-#   define ACE_MEM_POOL_1 class _ACE_MEM_POOL
+#   define ACE_MEM_POOL_1 typename _ACE_MEM_POOL
 #   define ACE_MEM_POOL_2 _ACE_MEM_POOL
 #   define ACE_MEM_POOL _ACE_MEM_POOL
 #   define ACE_MEM_POOL_OPTIONS typename _ACE_MEM_POOL::OPTIONS
 
+// @deprecated These macros are not longer used in ACE_Svc_Handler.
 // Handle ACE_Svc_Handler
-#   define ACE_PEER_STREAM_1 class _ACE_PEER_STREAM
+#   define ACE_PEER_STREAM_1 typename _ACE_PEER_STREAM
 #   define ACE_PEER_STREAM_2 _ACE_PEER_STREAM
 #   define ACE_PEER_STREAM _ACE_PEER_STREAM
 #   define ACE_PEER_STREAM_ADDR typename _ACE_PEER_STREAM::PEER_ADDR
 
+// @deprecated These macros are not longer used in ACE_Acceptor.
 // Handle ACE_Acceptor
-#   define ACE_PEER_ACCEPTOR_1 class _ACE_PEER_ACCEPTOR
+#   define ACE_PEER_ACCEPTOR_1 typename _ACE_PEER_ACCEPTOR
 #   define ACE_PEER_ACCEPTOR_2 _ACE_PEER_ACCEPTOR
 #   define ACE_PEER_ACCEPTOR _ACE_PEER_ACCEPTOR
 #   define ACE_PEER_ACCEPTOR_ADDR typename _ACE_PEER_ACCEPTOR::PEER_ADDR
 
+// @deprecated These macros are not longer used in ACE_Connector.
 // Handle ACE_Connector
-#   define ACE_PEER_CONNECTOR_1 class _ACE_PEER_CONNECTOR
+#   define ACE_PEER_CONNECTOR_1 typename _ACE_PEER_CONNECTOR
 #   define ACE_PEER_CONNECTOR_2 _ACE_PEER_CONNECTOR
 #   define ACE_PEER_CONNECTOR _ACE_PEER_CONNECTOR
 #   define ACE_PEER_CONNECTOR_ADDR typename ACE_PEER_CONNECTOR::PEER_ADDR
diff --git a/ACE/ace/SOCK_IO.h b/ACE/ace/SOCK_IO.h
index f301c9c4085..ecdf4e4ea86 100644
--- a/ACE/ace/SOCK_IO.h
+++ b/ACE/ace/SOCK_IO.h
@@ -29,7 +29,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * @class ACE_SOCK_IO
  *
  * @brief Defines the methods for the ACE socket wrapper I/O routines
- * (e.g., send/recv).
+ * described below.
  *
  * If @a timeout == 0, then the call behaves as a normal
  * send/recv call, i.e., for blocking sockets, the call will
diff --git a/ACE/ace/Svc_Handler.cpp b/ACE/ace/Svc_Handler.cpp
index ce43c811b16..3621a8e0b07 100644
--- a/ACE/ace/Svc_Handler.cpp
+++ b/ACE/ace/Svc_Handler.cpp
@@ -15,31 +15,28 @@
 
 #include "ace/Dynamic.h"
 
-#define PR_ST_1 ACE_PEER_STREAM_1
-#define PR_ST_2 ACE_PEER_STREAM_2
-
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
-template <PR_ST_1, ACE_SYNCH_DECL> void *
-ACE_Svc_Handler<PR_ST_2,  ACE_SYNCH_USE>::operator new (size_t, void *p)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t, void *p)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (NOOP, 2 parameters)");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (NOOP, 2 parameters)");
   return p;
 }
 
 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *, void *)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *, void *)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (NOOP, 2 parameters)");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (NOOP, 2 parameters)");
   return;
 }
 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
 
-template <PR_ST_1, ACE_SYNCH_DECL> void *
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t n)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new");
 
   ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
 
@@ -63,11 +60,11 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n)
 }
 
 #if defined (ACE_HAS_NEW_NOTHROW)
-template <PR_ST_1, ACE_SYNCH_DECL> void *
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n,
-                                                       const ACE_nothrow_t&) throw()
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t n,
+                                                          const ACE_nothrow_t&) throw()
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new(nothrow)");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new(nothrow)");
 
   ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
 
@@ -91,21 +88,21 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n,
 }
 
 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *p,
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *p,
                                          const ACE_nothrow_t&) throw()
 {
-  ACE_TRACE("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete(nothrow)");
+  ACE_TRACE("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete(nothrow)");
   ::delete [] static_cast <char *> (p);
 }
 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
 
 #endif /* ACE_HAS_NEW_NOTHROW */
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::destroy (void)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::destroy");
 
   // Only delete ourselves if we're not owned by a module and have
   // been allocated dynamically.
@@ -117,10 +114,10 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy (void)
     delete this;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *obj)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *obj)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete");
   // You cannot delete a 'void*' (X3J16/95-0087 5.3.5.3), but we know
   // the pointer was created using new char[] (see operator new code),
   // so we use a cast:
@@ -129,16 +126,16 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *obj)
 
 // Default constructor.
 
-template <PR_ST_1, ACE_SYNCH_DECL>
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler (ACE_Thread_Manager *tm,
-                                                          ACE_Message_Queue<ACE_SYNCH_USE> *mq,
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Svc_Handler (ACE_Thread_Manager *tm,
+                                                          ACE_Message_Queue<SYNCH_TRAITS> *mq,
                                                           ACE_Reactor *reactor)
-  : ACE_Task<ACE_SYNCH_USE> (tm, mq),
+  : ACE_Task<SYNCH_TRAITS> (tm, mq),
     closing_ (false),
     recycler_ (0),
     recycling_act_ (0)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Svc_Handler");
 
   this->reactor (reactor);
 
@@ -159,10 +156,10 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler (ACE_Thread_Manager *tm
 // Default behavior for a ACE_Svc_Handler object is to be registered
 // with the ACE_Reactor (thereby ensuring single threading).
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open (void *)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::open (void *)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::open");
 #if defined (ACELIB_DEBUGGING)
   ACE_TCHAR buf[BUFSIZ];
   ACE_PEER_STREAM_ADDR client_addr;
@@ -195,10 +192,10 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open (void *)
 
 // Perform termination activities.
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::shutdown (void)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::shutdown");
 
   // Deregister this handler with the ACE_Reactor.
   if (this->reactor ())
@@ -221,10 +218,10 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown (void)
   this->peer ().close ();
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint (void **act_holder)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::cleanup_hint (void **act_holder)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::cleanup_hint");
 
   // Remove as hint.
   if (this->recycler ())
@@ -232,11 +229,11 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint (void **act_holder)
                                      act_holder);
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump");
 
   this->peer_.dump ();
   ACELIB_DEBUG ((LM_DEBUG,
@@ -254,35 +251,35 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> ACE_PEER_STREAM &
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> PEER_STREAM &
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::peer (void) const
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer");
-  return (ACE_PEER_STREAM &) this->peer_;
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::peer");
+  return (PEER_STREAM &) this->peer_;
 }
 
 // Extract the underlying I/O descriptor.
 
-template <PR_ST_1, ACE_SYNCH_DECL> ACE_HANDLE
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_HANDLE
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::get_handle (void) const
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::get_handle");
   return this->peer_.get_handle ();
 }
 
 // Set the underlying I/O descriptor.
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle (ACE_HANDLE h)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::set_handle (ACE_HANDLE h)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::set_handle");
   this->peer_.set_handle (h);
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL>
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Svc_Handler (void)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Svc_Handler");
 
   if (this->closing_ == false)
     {
@@ -295,11 +292,11 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler (void)
     }
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close (ACE_HANDLE,
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_close (ACE_HANDLE,
                                                        ACE_Reactor_Mask)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_close");
 
   if (this->reference_counting_policy ().value () ==
       ACE_Event_Handler::Reference_Counting_Policy::DISABLED)
@@ -310,45 +307,45 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close (ACE_HANDLE,
   return 0;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout (const ACE_Time_Value &,
                                                          const void *)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout");
   return this->handle_close ();
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close (u_long)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::close (u_long)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::close");
   return this->handle_close ();
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init (int /* argc */,
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::init (int /* argc */,
                                                ACE_TCHAR * /* argv */[])
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::init");
   return -1;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::fini (void)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::fini");
   return -1;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info (ACE_TCHAR **, size_t) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::info (ACE_TCHAR **, size_t) const
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::info");
   return -1;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::idle (u_long flags)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::idle (u_long flags)
 {
   if (this->recycler ())
     return this->recycler ()->cache (this->recycling_act_);
@@ -356,8 +353,8 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::idle (u_long flags)
     return this->close (flags);
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (ACE_Recyclable_State new_state)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle_state (ACE_Recyclable_State new_state)
 {
   if (this->recycler ())
     return this->recycler ()->recycle_state (this->recycling_act_,
@@ -366,8 +363,8 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (ACE_Recyclable_State new
   return 0;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> ACE_Recyclable_State
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_Recyclable_State
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle_state (void) const
 {
   if (this->recycler ())
     return this->recycler ()->recycle_state (this->recycling_act_);
@@ -375,55 +372,55 @@ ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (void) const
   return ACE_RECYCLABLE_UNKNOWN;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (ACE_Connection_Recycling_Strategy *recycler,
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler (ACE_Connection_Recycling_Strategy *recycler,
                                                    const void *recycling_act)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler");
   this->recycler_ = recycler;
   this->recycling_act_ = recycling_act;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> ACE_Connection_Recycling_Strategy *
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_Connection_Recycling_Strategy *
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler (void) const
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler");
   return this->recycler_;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> const void *
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> const void *
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycling_act (void) const
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycling_act");
   return this->recycling_act_;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle (void *)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle (void *)
 {
-  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle");
+  ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle");
   // By default, the object is ready and willing to be recycled.
   return 0;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL>
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Buffered_Svc_Handler (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Buffered_Svc_Handler (void)
 {
   this->flush ();
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL>
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler (ACE_Thread_Manager *tm,
-                                                                            ACE_Message_Queue<ACE_SYNCH_USE> *mq,
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Buffered_Svc_Handler (ACE_Thread_Manager *tm,
+                                                                            ACE_Message_Queue<SYNCH_TRAITS> *mq,
                                                                             ACE_Reactor *reactor,
                                                                             size_t maximum_buffer_size,
                                                                             ACE_Time_Value *timeout)
-  : ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE> (tm, mq, reactor),
+  : ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS> (tm, mq, reactor),
     maximum_buffer_size_ (maximum_buffer_size),
     current_buffer_size_ (0),
     timeoutp_ (timeout)
 {
-  ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler");
+  ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Buffered_Svc_Handler");
 
   if (this->timeoutp_ != 0)
     {
@@ -432,11 +429,11 @@ ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler (ACE_
     }
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
-                                                       ACE_Time_Value *tv)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::put (ACE_Message_Block *mb,
+                                                          ACE_Time_Value *tv)
 {
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
+  ACE_GUARD_RETURN (typename SYNCH_TRAITS::MUTEX, m, this->msg_queue ()->lock (), -1);
 
   // Enqueue <mb> onto the message queue.
   if (this->putq (mb, tv) == -1)
@@ -459,18 +456,18 @@ ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
 
 // Flush the buffer.
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::flush (void)
 {
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
+  ACE_GUARD_RETURN (typename SYNCH_TRAITS::MUTEX, m, this->msg_queue ()->lock (), -1);
 
   return this->flush_i ();
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush_i (void)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::flush_i (void)
 {
-  ACE_Message_Queue_Iterator<ACE_SYNCH_USE> iterator (*this->msg_queue ());
+  ACE_Message_Queue_Iterator<SYNCH_TRAITS> iterator (*this->msg_queue ());
   ACE_Message_Block *mblk = 0;
   ssize_t result = 0;
 
@@ -492,13 +489,13 @@ ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush_i (void)
   return result;
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> void
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
+template <typename PEER_STREAM, typename SYNCH_TRAITS> void
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
+  ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump");
 
-  ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump ();
+  ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump ();
   ACELIB_DEBUG ((LM_DEBUG,
               "maximum_buffer_size_ = %d\n",
               this->maximum_buffer_size_));
@@ -513,16 +510,14 @@ ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <PR_ST_1, ACE_SYNCH_DECL> int
-ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
-                                                                  const void *)
+template <typename PEER_STREAM, typename SYNCH_TRAITS> int
+ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout (const ACE_Time_Value &,
+                                                                     const void *)
 {
-  ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
+  ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout");
   return 0;
 }
 
 ACE_END_VERSIONED_NAMESPACE_DECL
 
-#undef PR_ST_1
-#undef PR_ST_2
 #endif /* ACE_SVC_HANDLER_CPP */
diff --git a/ACE/ace/Svc_Handler.h b/ACE/ace/Svc_Handler.h
index 741e6102e95..5a8fbbfa9fe 100644
--- a/ACE/ace/Svc_Handler.h
+++ b/ACE/ace/Svc_Handler.h
@@ -53,14 +53,14 @@ enum ACE_Svc_Handler_Close { NORMAL_CLOSE_OPERATION = 0x00,
  * This endpoint is used to exchange data between a
  * ACE_Svc_Handler and the peer it is connected with.
  */
-template <ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
-class ACE_Svc_Handler : public ACE_Task<ACE_SYNCH_USE>
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+class ACE_Svc_Handler : public ACE_Task<SYNCH_TRAITS>
 {
 public:
 
   // Useful STL-style traits.
-  typedef ACE_PEER_STREAM_ADDR addr_type;
-  typedef ACE_PEER_STREAM      stream_type;
+  typedef typename PEER_STREAM::PEER_ADDR addr_type;
+  typedef PEER_STREAM stream_type;
 
   /**
    * Constructor initializes the @a thr_mgr and @a mq by passing them
@@ -68,15 +68,17 @@ public:
    * the ACE_Event_Handler.
    */
   ACE_Svc_Handler (ACE_Thread_Manager *thr_mgr = 0,
-                   ACE_Message_Queue<ACE_SYNCH_USE> *mq = 0,
+                   ACE_Message_Queue<SYNCH_TRAITS> *mq = 0,
                    ACE_Reactor *reactor = ACE_Reactor::instance ());
 
   /// Destructor.
   virtual ~ACE_Svc_Handler (void);
 
   /// Activate the client handler.  This is typically called by the
-  /// ACE_Acceptor or ACE_Connector.
-  virtual int open (void * = 0);
+  /// ACE_Acceptor or ACE_Connector, which passes "this" in as the
+  /// parameter to open.  If this method returns -1 the Svc_Handler's
+  /// close() method is automatically called.
+  virtual int open (void *acceptor_or_connector = 0);
 
   /**
    * Object termination hook -- application-specific cleanup code goes
@@ -148,8 +150,8 @@ public:
   virtual void set_handle (ACE_HANDLE);
 
   /// Returns the underlying PEER_STREAM.  Used by
-  /// <ACE_Acceptor::accept> and <ACE_Connector::connect> factories
-  ACE_PEER_STREAM &peer (void) const;
+  /// <ACE_Acceptor::accept> and <ACE_Connector::connect> factories.
+  PEER_STREAM &peer (void) const;
 
   /// Overloaded new operator.  This method unobtrusively records if a
   /// <Svc_Handler> is allocated dynamically, which allows it to clean
@@ -234,7 +236,7 @@ public:
 
 protected:
   /// Maintain connection with client.
-  ACE_PEER_STREAM peer_;
+  PEER_STREAM peer_;
 
   /// Have we been dynamically created?
   bool dynamic_;
@@ -262,8 +264,8 @@ protected:
  * queue is "full" or (2) a period of time elapses, at which
  * point the queue is "flushed" via <sendv_n> to the peer.
  */
-template <ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
-class ACE_Buffered_Svc_Handler : public ACE_Svc_Handler<ACE_PEER_STREAM_2, ACE_SYNCH_USE>
+template <typename PEER_STREAM, typename SYNCH_TRAITS>
+class ACE_Buffered_Svc_Handler : public ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>
 {
 public:
   // = Initialization and termination methods.
@@ -277,7 +279,7 @@ public:
    * relative to the current time returned by <ACE_OS::gettimeofday>.
    */
   ACE_Buffered_Svc_Handler (ACE_Thread_Manager *thr_mgr = 0,
-                            ACE_Message_Queue<ACE_SYNCH_USE> *mq = 0,
+                            ACE_Message_Queue<SYNCH_TRAITS> *mq = 0,
                             ACE_Reactor *reactor = ACE_Reactor::instance (),
                             size_t max_buffer_size = 0,
                             ACE_Time_Value *relative_timeout = 0);
diff --git a/ACE/examples/C++NPv2/TPC_Logging_Server.cpp b/ACE/examples/C++NPv2/TPC_Logging_Server.cpp
index b6ce76e1d40..9f4a607f7f3 100644
--- a/ACE/examples/C++NPv2/TPC_Logging_Server.cpp
+++ b/ACE/examples/C++NPv2/TPC_Logging_Server.cpp
@@ -98,7 +98,6 @@ int TPC_Logging_Acceptor::accept_svc_handler
   return 0;
 }
 
-
 typedef Reactor_Logging_Server_Adapter<TPC_Logging_Acceptor>
         TPC_Logging_Server;
 
diff --git a/ACE/examples/Connection/misc/Connection_Handler.cpp b/ACE/examples/Connection/misc/Connection_Handler.cpp
index efe96f514c0..0d540b08775 100644
--- a/ACE/examples/Connection/misc/Connection_Handler.cpp
+++ b/ACE/examples/Connection/misc/Connection_Handler.cpp
@@ -5,17 +5,16 @@
  *
  *  $Id$
  *
- *    This test illustrates how to use the Acceptor pattern to
- *    create multiple threads, each running its own Reactor.  You
- *    can connect to this via telnet and keep typing until you enter
- *    '^D'.
+ *    This test illustrates how to use the Acceptor role of the
+ *    Acceptor-Connector pattern to create multiple threads, each
+ *    running its own Reactor.  You can connect to this via telnet and
+ *    keep typing until you enter '^D'.
  *
  *
  *  @author Doug Schmidt
  */
 //=============================================================================
 
-
 #include "ace/Acceptor.h"
 #include "ace/SOCK_Acceptor.h"
 #include "ace/Service_Config.h"
@@ -24,8 +23,6 @@
 
 #include "Connection_Handler.h"
 
-
-
 int
 Connection_Handler::open (void *)
 {
diff --git a/ACE/tests/Future_Test.cpp b/ACE/tests/Future_Test.cpp
index 5a418583147..deabf651171 100644
--- a/ACE/tests/Future_Test.cpp
+++ b/ACE/tests/Future_Test.cpp
@@ -6,12 +6,11 @@
  *  $Id$
  *
  *  This example tests the ACE Future and illustrates an
- *  implementation of the Active Object pattern, which is described
- *  in the POSA2 book <www.cs.wustl.edu/~schmidt/POSA/> and in a
- *  paper at <www.cs.wustl.edu/~schmidt/PDF/Act-Obj.pdf>.  The
- *  Active Object example here is very simple -- it determines if numbers
- *  are prime.
- *
+ *  implementation of the Active Object pattern, which is described in
+ *  the POSA2 book <www.dre.vanderbilt.edu/~schmidt/POSA/> and in a
+ *  paper at <www.dre.vanderbilt.edu/~schmidt/PDF/Act-Obj.pdf>.  The
+ *  Active Object example here is very simple -- it determines if
+ *  numbers are prime.
  *
  *  @author Andres Kruse <Andres.Kruse@cern.ch>
  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
@@ -19,7 +18,6 @@
  */
 //=============================================================================
 
-
 #include "test_config.h"
 #include "ace/OS_NS_string.h"
 #include "ace/OS_NS_sys_time.h"
@@ -32,9 +30,6 @@
 #include "ace/Auto_Ptr.h"
 #include "ace/Atomic_Op.h"
 
-
-
-
 #if defined (ACE_HAS_THREADS)
 
 typedef ACE_Atomic_Op<ACE_Thread_Mutex, int> ATOMIC_INT;
author	schmidt <douglascraigschmidt@users.noreply.github.com>	2013-04-24 15:01:48 +0000
committer	schmidt <douglascraigschmidt@users.noreply.github.com>	2013-04-24 15:01:48 +0000
commit	4a2b25b62b35e57b7ee5a677575a4a94c106c1a8 (patch)
tree	c506664051fc00b667c8be8ea6f917ff893ac1e6
parent	be48c1011fb0bda61530415d9af16f88322582b8 (diff)
download	ATCD-4a2b25b62b35e57b7ee5a677575a4a94c106c1a8.tar.gz