diff options
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 | 4197b1898b4319904f38397662656079af8d945b (patch) | |
tree | c506664051fc00b667c8be8ea6f917ff893ac1e6 /ACE | |
parent | 85fe74ccaac59923bc6a39e31fdbb16974028a42 (diff) | |
download | ATCD-4197b1898b4319904f38397662656079af8d945b.tar.gz |
ChangeLogTag:Wed
Diffstat (limited to 'ACE')
-rw-r--r-- | ACE/ACE-INSTALL.html | 2 | ||||
-rw-r--r-- | ACE/ChangeLog | 33 | ||||
-rw-r--r-- | ACE/THANKS | 2 | ||||
-rw-r--r-- | ACE/ace/Acceptor.cpp | 405 | ||||
-rw-r--r-- | ACE/ace/Acceptor.h | 68 | ||||
-rw-r--r-- | ACE/ace/Connector.cpp | 271 | ||||
-rw-r--r-- | ACE/ace/Connector.h | 70 | ||||
-rw-r--r-- | ACE/ace/Global_Macros.h | 13 | ||||
-rw-r--r-- | ACE/ace/SOCK_IO.h | 2 | ||||
-rw-r--r-- | ACE/ace/Svc_Handler.cpp | 231 | ||||
-rw-r--r-- | ACE/ace/Svc_Handler.h | 28 | ||||
-rw-r--r-- | ACE/examples/C++NPv2/TPC_Logging_Server.cpp | 1 | ||||
-rw-r--r-- | ACE/examples/Connection/misc/Connection_Handler.cpp | 11 | ||||
-rw-r--r-- | ACE/tests/Future_Test.cpp | 15 |
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; |