diff options
author | irfan <irfan@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 1999-07-12 19:20:35 +0000 |
---|---|---|
committer | irfan <irfan@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 1999-07-12 19:20:35 +0000 |
commit | 11836adaf31ea5e6fc4f97c34bff8930ec3e5d23 (patch) | |
tree | 4152f0e4a98529cb2b54703bf873c9371a83af24 /tests/Cached_Conn_Test.cpp | |
parent | 463cf609c064772619ff0f3651b1b77803ac32b0 (diff) | |
download | ATCD-11836adaf31ea5e6fc4f97c34bff8930ec3e5d23.tar.gz |
ChangeLogTag:Mon Jul 12 13:54:34 1999 Kirthika Parameswaran <kirthika@cs.wustl.edu>
Diffstat (limited to 'tests/Cached_Conn_Test.cpp')
-rw-r--r-- | tests/Cached_Conn_Test.cpp | 567 |
1 files changed, 280 insertions, 287 deletions
diff --git a/tests/Cached_Conn_Test.cpp b/tests/Cached_Conn_Test.cpp index 39ffc3f235f..799e5f9831e 100644 --- a/tests/Cached_Conn_Test.cpp +++ b/tests/Cached_Conn_Test.cpp @@ -9,11 +9,11 @@ // Cached_Conn_Test.cpp // // = DESCRIPTION -// The test illustrates how the <ACE_Strategy_Connector> works by -// showing how you can cache connections on the client using -// different caching strategies. Also how connections can be purged -// explicitly if needed from the connection cache maintained by the -// connector. +// The test illustrates how the <ACE_Strategy_Connector> works by +// showing how you can cache connections on the client using +// different caching strategies. Also how connections can be purged +// explicitly and implicitly if needed from the connection cache +// maintained by the connector. // // = AUTHOR // Kirthika Parameswaran <kirthika@cs.wustl.edu> @@ -24,9 +24,13 @@ #define CACHED_CONNECT_TEST #include "test_config.h" + +#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 +#define ACE_HAS_BROKEN_EXTENDED_TEMPLATES +#endif /* __GNUC__ */ + #include "ace/INET_Addr.h" #include "ace/Strategies.h" -#include "ace/Auto_Ptr.h" #include "ace/SOCK_Connector.h" #include "ace/SOCK_Acceptor.h" #include "ace/Svc_Handler.h" @@ -37,6 +41,10 @@ #include "ace/Caching_Utility_T.h" #include "ace/Cached_Connect_Strategy_T.h" +#if defined(_MSC_VER) +#pragma warning(disable:4503) +#endif /* _MSC_VER */ + ACE_RCSID(tests, Cached_Conn_Test, "$Id$") #if defined(__BORLANDC__) && __BORLANDC__ >= 0x0530 @@ -44,150 +52,156 @@ USELIB("..\ace\aced.lib"); //--------------------------------------------------------------------------- #endif /* defined(__BORLANDC__) && __BORLANDC__ >= 0x0530 */ -// Default number of clients/servers. -static int n_servers = 3000; -static double purge_percentage = 20; - -enum Caching_Strategy_Type -{ - ACE_LFU, - ACE_FIFO, - ACE_LRU, - ACE_NULL, - ACE_ALL -}; -static Caching_Strategy_Type caching_strategy_type = ACE_ALL; +static int debug = 0; class Svc_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> { - public: Svc_Handler (ACE_Thread_Manager *t = 0) : ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> (t) { } - + int open (void *v = 0) { - ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::open (v); - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) opening Svc_Handler %d with handle %d\n"), - this, - this->peer ().get_handle ())); + ACE_UNUSED_ARG (v); + if (debug) + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("opening Svc_Handler %d with handle %d\n"), + this, + this->peer ().get_handle ())); return 0; } - - int close (u_long flags = 0) - { - ACE_UNUSED_ARG (flags); - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) Closing Svc_Handler %d with handle %d\n"), - this, - this->peer ().get_handle ())); - return this->handle_close (); - } - int idle (u_long flags = 0) + int close (u_long flags = 0) { ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) idling Svc_Handler %d with handle %d\n"), + ASYS_TEXT ("Closing Svc_Handler %d with handle %d\n"), this, this->peer ().get_handle ())); - return ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::idle (flags); + return ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::close (flags); } - }; typedef size_t ATTRIBUTES; -typedef ACE_Pair<Svc_Handler *, ATTRIBUTES> +typedef ACE_Pair<Svc_Handler *, ATTRIBUTES> CACHED_HANDLER; typedef ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> - REFCOUNTED_HASH_RECYCLABLE_ADDR; -typedef ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR> H_KEY; -typedef ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR> C_KEYS; + ADDR; +typedef ACE_Hash<ADDR> H_KEY; +typedef ACE_Equal_To<ADDR> C_KEYS; -typedef ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>,\ - ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex> +typedef ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> HASH_MAP; -typedef ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, \ - ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex> +typedef ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> HASH_MAP_ITERATOR; -typedef ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>,\ - ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex> +typedef ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> HASH_MAP_REVERSE_ITERATOR; -typedef ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP> +typedef ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP> CLEANUP_STRATEGY; -typedef ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES> +typedef ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES> CACHING_UTILITY; -typedef ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> +typedef ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> CACHING_STRATEGY; -typedef ACE_LRU_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> +typedef ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> LRU_CACHING_STRATEGY; -typedef ACE_LFU_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> +typedef ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> LFU_CACHING_STRATEGY; -typedef ACE_FIFO_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> +typedef ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> FIFO_CACHING_STRATEGY; -typedef ACE_Null_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> +typedef ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> NULL_CACHING_STRATEGY; -typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY > +typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY > LRU_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY> +typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY> LFU_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY> +typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY> FIFO_CACHING_STRATEGY_ADAPTER; -typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY> +typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY> NULL_CACHING_STRATEGY_ADAPTER; typedef ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR> ACCEPTOR; - + typedef ACE_Strategy_Connector<Svc_Handler, ACE_SOCK_CONNECTOR> STRATEGY_CONNECTOR; - + typedef ACE_NOOP_Creation_Strategy<Svc_Handler> NULL_CREATION_STRATEGY; - + typedef ACE_NOOP_Concurrency_Strategy<Svc_Handler> NULL_ACTIVATION_STRATEGY; - + typedef ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX> CACHED_CONNECT_STRATEGY; +enum Caching_Strategy_Type +{ + ACE_LFU, + ACE_FIFO, + ACE_LRU, + ACE_NULL, + ACE_ALL +}; + +// Default number of clients/servers. +static int default_iterations = 3000; +static int iterations = default_iterations; +static double purge_percentage = 20; +static Caching_Strategy_Type caching_strategy_type = ACE_ALL; +static CACHED_CONNECT_STRATEGY *connect_strategy = 0; + //==================================================================== +static void +out_of_sockets_handler (void) +{ + // ENOBUFS had to be checked on NT while ENOENT check had to be added for + // Solaris + Linux. + if (errno == EMFILE || errno == ENOBUFS || errno == ENOENT) + { + // Close connections which are cached by explicitly purging the + // connection cache maintained by the connector. + ACE_DEBUG ((LM_DEBUG, "Purging connections from Connection Cache...\n")); + + int retval = connect_strategy->purge_connections (purge_percentage); + ACE_ASSERT (retval != -1); + } + else + { + ACE_ERROR ((LM_ERROR, + ASYS_TEXT ("%p\n"), + ASYS_TEXT ("out_of_sockets_handler failed!"))); + // This shouldn't happen! + ACE_ASSERT (0); + } +} static int cached_connect (STRATEGY_CONNECTOR &con, const ACE_INET_Addr &server_addr) { - Svc_Handler *svc_handler = 0; - + // This will make sure we get the host information correct. + ACE_INET_Addr remote_addr (server_addr.get_port_number (), + ACE_DEFAULT_SERVER_HOST); + // Perform a blocking connect to the server using the Strategy - // Connector with a connection caching strategy. Since we are - // connecting to the same <server_addr> these calls will return - // the same dynamically allocated <Svc_Handler> for each - // <connect>. + // Connector with a connection caching strategy. + Svc_Handler *svc_handler = 0; int result = con.connect (svc_handler, - server_addr); + remote_addr); if (result == -1) ACE_ERROR_RETURN ((LM_ERROR, - ASYS_TEXT ("(%P|%t) %p\n"), + ASYS_TEXT ("%p\n"), ASYS_TEXT ("connection failed")), -1); - - // Send the data to the server. - for (char *c = ACE_ALPHABET; *c != '\0'; c++) - if (svc_handler->peer ().send_n (c, 1) == -1) - ACE_ERROR_RETURN ((LM_ERROR, - ASYS_TEXT ("(%P|%t) %p\n"), - ASYS_TEXT ("send_n")), - -1); - + // Svc_Handler is now idle, so mark it as such and let the cache // recycle it. svc_handler->idle (1); + return 0; } @@ -195,133 +209,88 @@ static int server (ACCEPTOR *acceptor) { ACE_INET_Addr cli_addr; - + // Create a new <Svc_Handler> to consume the data. Svc_Handler svc_handler; - + int result = acceptor->accept (&svc_handler, &cli_addr); if (result == -1) - { - if (errno == EMFILE) - return 1; - - return -1; - } + return -1; - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) client %s connected from %d\n"), - cli_addr.get_host_name (), - cli_addr.get_port_number ())); - - char c; - char *t = ACE_ALPHABET; - ssize_t r_bytes = 0; - - // Read data from client (terminate on error). - while ((r_bytes == svc_handler.peer ().recv_n (&c, 1)) > 0) - { - ACE_ASSERT (*t == c); - - // We need to guard against cached connections, which - // will send multiple sequences of letters from 'a' -> - // 'z' through the same connection. - if (*t == 'z') - t = ACE_ALPHABET; - else - t++; - } - - if (r_bytes == 0) + if (debug) ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) reached end of input, connection closed by client\n"))); - else if (r_bytes == -1) - { - if (errno == EWOULDBLOCK) - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) no input available, going back to reading\n"))); - else - ACE_ERROR_RETURN ((LM_ERROR, - ASYS_TEXT ("(%P|%t) %p\n"), - ASYS_TEXT ("recv_n")), - -1); - } + ASYS_TEXT ("client %s connected from %d\n"), + cli_addr.get_host_name (), + cli_addr.get_port_number ())); + // + // Svc_Handler dies here, closing the server side socket. + // return 0; } - static void test_connection_management (CACHING_STRATEGY &caching_strategy) { - NULL_CREATION_STRATEGY creation_strategy; - NULL_ACTIVATION_STRATEGY activation_strategy; - // Configure the Strategy Connector with a strategy that caches // connection. CACHED_CONNECT_STRATEGY caching_connect_strategy (caching_strategy); - + + // This is required by the <out_of_sockets_handler>. + connect_strategy = &caching_connect_strategy; + + NULL_CREATION_STRATEGY creation_strategy; + NULL_ACTIVATION_STRATEGY activation_strategy; + STRATEGY_CONNECTOR strategy_connector (0, &creation_strategy, &caching_connect_strategy, &activation_strategy); - - // Set the purging percentage explicitly. By default it is 10%. - // Note: The purge_percent could have been set before itself but, - // the following has been done just to show how one would explicitly - // set the purge_percent at any moment. - CACHED_CONNECT_STRATEGY *connect_strategy = - ACE_dynamic_cast (CACHED_CONNECT_STRATEGY *, - strategy_connector.connect_strategy ()); - - connect_strategy->caching_strategy ().purge_percent (purge_percentage); - - for (int i = 0; i < n_servers; ++i) + + for (int i = 0; i < iterations; ++i) { + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("iteration %d\n"), + i)); + // Acceptor ACCEPTOR acceptor; ACE_INET_Addr server_addr; - + // Bind acceptor to any port and then find out what the port // was. - if (acceptor.open (ACE_sap_any_cast (const ACE_INET_Addr &)) == -1 - || acceptor.acceptor ().get_local_addr (server_addr) == -1) + + if (acceptor.open (ACE_sap_any_cast (const ACE_INET_Addr &)) == -1) { - ACE_ERROR ((LM_ERROR, - ASYS_TEXT ("(%P|%t) %p\n"), - ASYS_TEXT ("open"))); - return; + out_of_sockets_handler (); + continue; } - else + + if (acceptor.acceptor ().get_local_addr (server_addr) == -1) { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) starting server at port %d\n"), - server_addr.get_port_number ())); + ACE_ERROR ((LM_ERROR, + ASYS_TEXT ("%p\n"), + ASYS_TEXT ("open"))); + ACE_ASSERT (0); } - + + if (debug) + ACE_DEBUG ((LM_DEBUG, + ASYS_TEXT ("starting server at port %d\n"), + server_addr.get_port_number ())); + // Run the cached blocking test. - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("(%P|%t) *starting cached blocking connect\n"))); - int result = cached_connect (strategy_connector, server_addr); ACE_ASSERT (result != -1); - + result = server (&acceptor); - if (result == 1) - { - // Close connections which are cached by explicitly purging - // the connection cache maintained by the connector. - ACE_DEBUG ((LM_DEBUG, "Purging connections from Connection Cache...\n")); - - int retval = connect_strategy->purge_connections (purge_percentage); - ACE_ASSERT (retval != -1); - } - - ACE_ASSERT (result != -1); - } + if (result == -1) + out_of_sockets_handler (); + } } - + void test_caching_strategy_type (void) { @@ -352,11 +321,12 @@ test_caching_strategy_type (void) ACE_NEW (caching_strategy, FIFO_CACHING_STRATEGY_ADAPTER); break; - + case ACE_ALL: // Just to remove warnings! break; - } + } + caching_strategy->purge_percent (purge_percentage); test_connection_management (*caching_strategy); delete caching_strategy; } @@ -365,20 +335,26 @@ test_caching_strategy_type (void) int parse_args (int argc, char *argv[]) { - ACE_Get_Opt get_opt (argc, argv, "s:p:c:"); - + ACE_Get_Opt get_opt (argc, argv, "i:p:c:d"); + int cc; - + while ((cc = get_opt ()) != -1) switch (cc) { - case 's': - n_servers = atoi (get_opt.optarg); + case 'd': + debug = 1; + break; + case 'i': + iterations = atoi (get_opt.optarg); break; case 'p': purge_percentage = atoi (get_opt.optarg); break; - case 'c': // If Null Caching Strategy then this test will fail! + case 'c': + // Note that if null caching strategy is used then this test + // will fail if the number of servers exceed number of open + // files allowed for the process. if (ACE_OS::strcmp (get_opt.optarg, "null") == 0) caching_strategy_type = ACE_NULL; if (ACE_OS::strcmp (get_opt.optarg, "lru") == 0) @@ -392,10 +368,11 @@ parse_args (int argc, char *argv[]) case 'h': default: ACE_ERROR ((LM_ERROR, - "usage: %s " - "[-s (number of servers to connect to)] " - "[-p (purge percent)] " - "[-c (caching_strategy_type 0=NULL , 1=LRU, 2=LFU, 3=FIFO default=LRU)]\n", + ASYS_TEXT ("usage: %s ") + ASYS_TEXT ("[-c (caching strategy: lru / lfu / fifo / null [default = all])] ") + ASYS_TEXT ("[-i (iterations)] ") + ASYS_TEXT ("[-d (addition debugging output)] ") + ASYS_TEXT ("[-p (purge percent)] "), argv[0])); return -1; } @@ -407,21 +384,29 @@ int main (int argc, ASYS_TCHAR *argv[]) { + // Validate options. + int result = parse_args (argc, argv); + if (result != 0) + return result; + + // Start the test only if options are valid. ACE_START_TEST (ASYS_TEXT ("Cached_Conn_Test")); + + // Remove the extra debugging attributes from Log_Msg output. ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE); - - // Obtain the <number of servers> to connect to. Also the purge - // percentage using which the entries in the connection cache of - // the connector will be removed. - int result = parse_args (argc, argv); - ACE_ASSERT (result == 0); - // Do we need to test all the strategies. + // Do we need to test all the strategies. Note, that the less + // useful null strategy is ignored in this case. if (caching_strategy_type == ACE_ALL) { caching_strategy_type = ACE_LRU; test_caching_strategy_type (); + // Default iterations are too many; we the user hasn't specified + // otherwise, we'll shrink the iterations for LFU and FIFO. + if (iterations == default_iterations) + iterations = default_iterations / 100; + caching_strategy_type = ACE_LFU; test_caching_strategy_type (); @@ -432,7 +417,7 @@ main (int argc, { test_caching_strategy_type (); } - + ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE); ACE_END_TEST; return 0; @@ -448,16 +433,16 @@ template class ACE_Concurrency_Strategy<Svc_Handler>; template class ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR>; template class ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>; template class ACE_Creation_Strategy<Svc_Handler>; -template class ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>; -template class ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>; -template class ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>; -template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; -template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Entry<ADDR, Svc_Handler *>; +template class ACE_Hash<ADDR>; +template class ACE_Equal_To<ADDR>; +template class ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>; +template class ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>; template class ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *>; template class ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>; template class ACE_Map_Iterator_Base<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>; @@ -470,49 +455,53 @@ template class ACE_Svc_Tuple<Svc_Handler>; template class ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR>; template class ACE_Pair<Svc_Handler *, ATTRIBUTES>; -template class ACE_Reference_Pair<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>; -template class ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER>; - -template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>; -template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; - -template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>; -template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; -template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Reference_Pair<ADDR, Svc_Handler *>; +template class ACE_Hash_Map_Entry<ADDR, CACHED_HANDLER>; + +template class ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>; +template class ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>; +template class ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>; + +template class ACE_Hash_Map_Manager<ADDR, CACHED_HANDLER, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>; +template class ACE_Hash_Map_Reverse_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>; +template class ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Base_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>; // = Caching_Strategy -template class ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>; -template class ACE_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP, HASH_MAP::iterator, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>; -template class ACE_Cache_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::iterator, CACHING_STRATEGY, ATTRIBUTES>; -template class ACE_Cache_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>; +template class ACE_Hash_Cache_Map_Manager<ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>; + +#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) +template class ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, HASH_MAP_ITERATOR, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>; +template class ACE_Cache_Map_Iterator<ADDR, Svc_Handler *, HASH_MAP_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>; +template class ACE_Cache_Map_Reverse_Iterator<ADDR, Svc_Handler *, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>; +#else +template class ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, CACHING_STRATEGY, ATTRIBUTES>; +#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */ + template class ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX>; template class ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_NULL_MUTEX>; -template class ACE_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>; -template class ACE_Default_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>; -template class ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>; -template class ACE_Pair_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>; -template class ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>; +template class ACE_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>; +template class ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>; +template class ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES>; -template class ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>; -template class ACE_LRU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>; -template class ACE_LFU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>; -template class ACE_FIFO_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>; -template class ACE_Null_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>; +template class ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>; +template class ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>; +template class ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>; +template class ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>; +template class ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>; -template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY >; -template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY >; -template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY >; -template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY >; +template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY>; +template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY>; +template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY>; +template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) @@ -523,16 +512,16 @@ template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CAC #pragma instantiate ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR> #pragma instantiate ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR> #pragma instantiate ACE_Creation_Strategy<Svc_Handler> -#pragma instantiate ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *> -#pragma instantiate ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR> -#pragma instantiate ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR> -#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Entry<ADDR, Svc_Handler *> +#pragma instantiate ACE_Hash<ADDR> +#pragma instantiate ACE_Equal_To<ADDR> +#pragma instantiate ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX> #pragma instantiate ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *> #pragma instantiate ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX> #pragma instantiate ACE_Map_Iterator_Base<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX> @@ -541,54 +530,58 @@ template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CAC #pragma instantiate ACE_NOOP_Concurrency_Strategy<Svc_Handler> #pragma instantiate ACE_Recycling_Strategy<Svc_Handler> #pragma instantiate ACE_Strategy_Connector<Svc_Handler, ACE_SOCK_CONNECTOR> - #pragma instantiate ACE_Svc_Tuple<Svc_Handler> #pragma instantiate ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR> #pragma instantiate ACE_Pair<Svc_Handler *, ATTRIBUTES> -#pragma instantiate ACE_Reference_Pair<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *> -#pragma instantiate ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER> - -#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> - -#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> -#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Reference_Pair<ADDR, Svc_Handler *> +#pragma instantiate ACE_Hash_Map_Entry<ADDR, CACHED_HANDLER> + +#pragma instantiate ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex> + +#pragma instantiate ACE_Hash_Map_Manager<ADDR, CACHED_HANDLER, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex> // = Caching_Strategy -#pragma instantiate ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES> -#pragma instantiate ACE_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP, HASH_MAP::iterator, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES> -#pragma instantiate ACE_Cache_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::iterator, CACHING_STRATEGY, ATTRIBUTES> -#pragma instantiate ACE_Cache_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES> +#pragma instantiate ACE_Hash_Cache_Map_Manager<ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES> + +#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES) +#pragma instantiate ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, HASH_MAP_ITERATOR, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES> +#pragma instantiate ACE_Cache_Map_Iterator<ADDR, Svc_Handler *, HASH_MAP_ITERATOR, CACHING_STRATEGY, ATTRIBUTES> +#pragma instantiate ACE_Cache_Map_Reverse_Iterator<ADDR, Svc_Handler *, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES> +#else +#pragma instantiate ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, CACHING_STRATEGY, ATTRIBUTES> +#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */ + #pragma instantiate ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX> #pragma instantiate ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_NULL_MUTEX> -#pragma instantiate ACE_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP> -#pragma instantiate ACE_Default_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP> -#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES> -#pragma instantiate ACE_Pair_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES> -#pragma instantiate ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP> - -#pragma instantiate ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> -#pragma instantiate ACE_LRU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> -#pragma instantiate ACE_LFU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> -#pragma instantiate ACE_FIFO_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> -#pragma instantiate ACE_Null_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY> - -#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY > -#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY > -#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY > -#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY > +#pragma instantiate ACE_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP> +#pragma instantiate ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP> +#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES> + +#pragma instantiate ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> +#pragma instantiate ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> +#pragma instantiate ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> +#pragma instantiate ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> +#pragma instantiate ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY> + +#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY> +#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY> +#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY> +#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY> + #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ |