ChangeLogTag:Tue Aug 31 00:16:34 1999 Douglas C. Schmidt <schmidt@tango.cs.wustl.edu>

3 files changed, 147 insertions, 114 deletions

diff --git a/examples/Timer_Queue/Async_Timer_Queue_Test.cpp b/examples/Timer_Queue/Async_Timer_Queue_Test.cpp
index e05d11797fb..054dc3d2191 100644
--- a/examples/Timer_Queue/Async_Timer_Queue_Test.cpp
+++ b/examples/Timer_Queue/Async_Timer_Queue_Test.cpp
@@ -13,8 +13,9 @@
 //      using an <ACE_Timer_Heap>.
 //
 // = AUTHORS
-//    Douglas C. Schmidt and
-//    Sergio Flores-Gaitan
+//    Douglas C. Schmidt <schmidt@cs.wustl.edu> and
+//    Sergio Flores-Gaitan <sergio@cs.wustl.edu>
+//
 // ============================================================================
 
 #include "ace/Signal.h"
@@ -23,12 +24,22 @@
 
 #include "Async_Timer_Queue_Test.h"
 
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Async_Timer_Queue_Adapter<ACE_Timer_Heap>;
+template class Command<Async_Timer_Queue, Async_Timer_Queue::ACTION>;
+template class Timer_Queue_Test_Driver<Async_Timer_Queue *, Async_Timer_Queue, Async_Timer_Queue::ACTION>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Async_Timer_Queue_Adapter<ACE_Timer_Heap>
+#pragma instantiate Command<Async_Timer_Queue, Async_Timer_Queue::ACTION>
+#pragma instantiate Timer_Queue_Test_Driver<Async_Timer_Queue *, Async_Timer_Queue, Async_Timer_Queue::ACTION>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
 ACE_RCSID(Timer_Queue, Async_Timer_Queue_Test, "$Id$")
 
 // Hook method that is called to handle the expiration of a timer.
 int
 Async_Timer_Handler::handle_timeout (const ACE_Time_Value &tv,
-			       const void *arg)
+                                     const void *arg)
 {
   // Print some information here (note that this is not strictly
   // signal-safe since the ACE logging mechanism uses functions that
@@ -89,7 +100,8 @@ Async_Timer_Queue::dump (void)
        iter.next ())
     iter.item ()->dump ();
 
-  ACE_DEBUG ((LM_DEBUG, "end dumping timer queue\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "end dumping timer queue\n"));
 }
 
 // Schedule a timer.
@@ -102,7 +114,8 @@ Async_Timer_Queue::schedule (u_int microsecs)
   // Create a new Event_Handler for our timer.
 
   ACE_Event_Handler *eh;
-  ACE_NEW (eh, Async_Timer_Handler);
+  ACE_NEW (eh,
+           Async_Timer_Handler);
 
   // Schedule the timer to run in the future.
   long tid = this->tq_.schedule
@@ -111,7 +124,9 @@ Async_Timer_Queue::schedule (u_int microsecs)
      ACE_OS::gettimeofday () + tv);
 
   if (tid == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "schedule_timer"));
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "schedule_timer"));
 }
 
 // Cancel a timer.
@@ -119,12 +134,16 @@ Async_Timer_Queue::schedule (u_int microsecs)
 void
 Async_Timer_Queue::cancel (long timer_id)
 {
-  ACE_DEBUG ((LM_DEBUG, "canceling %d\n", timer_id));
+  ACE_DEBUG ((LM_DEBUG,
+              "canceling %d\n",
+              timer_id));
 
   const void *act = 0;
 
   if (this->tq_.cancel (timer_id, &act) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "cancel_timer"));
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "cancel_timer"));
 
   // In this case, the act will be 0, but it could be a real pointer
   // in other cases.
@@ -161,26 +180,23 @@ Async_Timer_Queue::cancel_timer (void *argument)
 // signal handler using SIGINT, not from the driver.
 
 int
-Async_Timer_Queue::list_timer (void *argument)
+Async_Timer_Queue::list_timer (void *)
 {
-  // Macro to avoid "warning: unused parameter" type warning.
-  ACE_UNUSED_ARG (argument);
-
   // Display an error message.
-  ACE_ERROR_RETURN ((LM_ERROR, "invalid input\n"), 0);
+  ACE_ERROR_RETURN ((LM_ERROR,
+                     "invalid input\n"), 0);
 }
 
 // Dummy shutdown timer hook method.  The shutdown of the timer queue
 // is done with a signal handler using SIGQUIT, not from the driver.
 
 int
-Async_Timer_Queue::shutdown_timer (void *argument)
+Async_Timer_Queue::shutdown_timer (void *)
 {
-  // Macro to avoid "warning: unused parameter" type warning.
-  ACE_UNUSED_ARG (argument);
-
   // Display an error message.
-  ACE_ERROR_RETURN ((LM_ERROR, "invalid input\n"), 0);
+  ACE_ERROR_RETURN ((LM_ERROR,
+                     "invalid input\n"),
+                    0);
 }
 
 // Handler for the SIGINT and SIGQUIT signals.
@@ -188,7 +204,9 @@ Async_Timer_Queue::shutdown_timer (void *argument)
 static void
 signal_handler (int signum)
 {
-  ACE_DEBUG ((LM_DEBUG, "handling signal %S\n", signum));
+  ACE_DEBUG ((LM_DEBUG,
+              "handling signal %S\n",
+              signum));
 
   switch (signum)
     {
@@ -198,7 +216,9 @@ signal_handler (int signum)
       /* NOTREACHED */
 
     case SIGQUIT:
-      ACE_ERROR ((LM_ERROR, "shutting down on SIGQUIT%a\n", 1));
+      ACE_ERROR ((LM_ERROR,
+                  "shutting down on SIGQUIT%a\n",
+                  1));
       /* NOTREACHED */
       break;
     }
@@ -248,8 +268,9 @@ Async_Timer_Queue_Test_Driver::display_menu (void)
     "^C list timers\n"
     "^\\ exit program\n";
 
-  ACE_DEBUG ((LM_DEBUG, "%s", menu));
-
+  ACE_DEBUG ((LM_DEBUG,
+              "%s",
+              menu));
   return 0;
 }
 
@@ -263,35 +284,25 @@ Async_Timer_Queue_Test_Driver::init (void)
   // Initialize <Command> objects with their corresponding <Input_Task> methods.
   ACE_NEW_RETURN (schedule_cmd_,
 		  CMD (*Async_Timer_Queue::instance (),
-			   &Async_Timer_Queue::schedule_timer),
+                       &Async_Timer_Queue::schedule_timer),
 		  -1);
 
   ACE_NEW_RETURN (cancel_cmd_,
 		  CMD (*Async_Timer_Queue::instance (),
-			   &Async_Timer_Queue::cancel_timer),
+                       &Async_Timer_Queue::cancel_timer),
 		  -1);
 
   ACE_NEW_RETURN (list_cmd_,
 		  CMD (*Async_Timer_Queue::instance (),
-			   &Async_Timer_Queue::list_timer),
+                       &Async_Timer_Queue::list_timer),
 		  -1);
 
   ACE_NEW_RETURN (shutdown_cmd_,
 		  CMD (*Async_Timer_Queue::instance (),
-			   &Async_Timer_Queue::shutdown_timer),
+                       &Async_Timer_Queue::shutdown_timer),
 		  -1);
 
   register_signal_handlers ();
 
   return 0;
 }
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Async_Timer_Queue_Adapter<ACE_Timer_Heap>;
-template class Command<Async_Timer_Queue, Async_Timer_Queue::ACTION>;
-template class Timer_Queue_Test_Driver<Async_Timer_Queue *, Async_Timer_Queue, Async_Timer_Queue::ACTION>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Async_Timer_Queue_Adapter<ACE_Timer_Heap>
-#pragma instantiate Command<Async_Timer_Queue, Async_Timer_Queue::ACTION>
-#pragma instantiate Timer_Queue_Test_Driver<Async_Timer_Queue *, Async_Timer_Queue, Async_Timer_Queue::ACTION>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/examples/Timer_Queue/Reactor_Timer_Queue_Test.cpp b/examples/Timer_Queue/Reactor_Timer_Queue_Test.cpp
index 819707e5f3e..06d3a643091 100644
--- a/examples/Timer_Queue/Reactor_Timer_Queue_Test.cpp
+++ b/examples/Timer_Queue/Reactor_Timer_Queue_Test.cpp
@@ -24,6 +24,14 @@
 #include "Driver.h"
 #include "Reactor_Timer_Queue_Test.h"
 
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class Timer_Queue_Test_Driver <ACE_Timer_Heap, Input_Handler, Input_Handler::ACTION>;
+template class Command<Input_Handler, Input_Handler::ACTION>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate Timer_Queue_Test_Driver <ACE_Timer_Heap, Input_Handler, Input_Handler::ACTION>
+#pragma instantiate Command<Input_Handler, Input_Handler::ACTION>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
 ACE_RCSID(Timer_Queue, Reactor_Timer_Queue_Test, "$Id$")
 
 void
@@ -40,8 +48,11 @@ Reactor_Timer_Handler::handle_timeout (const ACE_Time_Value &tv,
   ACE_UNUSED_ARG (tv);
 
   ACE_Time_Value txv = ACE_OS::gettimeofday ();
-  ACE_DEBUG ((LM_DEBUG, "\nTimer #%d fired at %d.%06d (%T)!\n",
-              this->tid_, txv.sec (), txv.usec ()));
+  ACE_DEBUG ((LM_DEBUG,
+              "\nTimer #%d fired at %d.%06d (%T)!\n",
+              this->tid_,
+              txv.sec (),
+              txv.usec ()));
   delete this;
 
   return 0;
@@ -75,7 +86,8 @@ Input_Handler::schedule_timer (void *argument)
                                               0,
                                               ACE_Time_Value (0, delay));
       if (tid == -1)
-        ACE_DEBUG ((LM_DEBUG, "Unable to schedule timer\n"));
+        ACE_DEBUG ((LM_DEBUG,
+                    "Unable to schedule timer\n"));
       else
         {
           ACE_DEBUG ((LM_DEBUG,
@@ -86,8 +98,9 @@ Input_Handler::schedule_timer (void *argument)
         }
     }
   else
-    ACE_ERROR_RETURN ((LM_ERROR, "not enough memory?\n"), -1);
-
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "not enough memory?\n"),
+                      -1);
   return tid;
 }
 
@@ -105,7 +118,8 @@ Input_Handler::shutdown_timer (void *argument)
   ACE_UNUSED_ARG (argument);
 
   this->done_ = 1;
-  ACE_DEBUG ((LM_DEBUG, "Shutting down event loop\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "Shutting down event loop\n"));
   return -1;
 }
 
@@ -116,9 +130,10 @@ Input_Handler::list_timer (void *argument)
   ACE_UNUSED_ARG (argument);
 
   ACE_Timer_Queue_Iterator &iter = this->tq_->iter ();
-  ACE_DEBUG ((LM_DEBUG, "\n\nTimers in queue:\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "\n\nTimers in queue:\n"));
 
-  for (; ! iter.isdone (); iter.next ())
+  for (; !iter.isdone (); iter.next ())
     {
       ACE_Timer_Node *tn = iter.item ();
       ACE_DEBUG ((LM_DEBUG, "Timer #%d: %d.%06d\n",
@@ -155,9 +170,10 @@ Reactor_Timer_Queue_Test_Driver::display_menu (void)
     "4) Shutdown program\n"
     "Enter selection:";
 
-  ACE_DEBUG ((LM_DEBUG, "%s", menu));
-
-  return  0;
+  ACE_DEBUG ((LM_DEBUG,
+              "%s",
+              menu));
+  return 0;
 }
 
 int
@@ -199,7 +215,8 @@ Reactor_Timer_Queue_Test_Driver::init (void)
 int
 Reactor_Timer_Queue_Test_Driver::run_test (void)
 {
-  ACE_DEBUG ((LM_DEBUG, "TIMER TEST STARTED\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "TIMER TEST STARTED\n"));
 
   this->init ();
 
@@ -207,14 +224,7 @@ Reactor_Timer_Queue_Test_Driver::run_test (void)
   while (thandler_.done () == 0)
     ACE_Reactor::instance ()->handle_events ();
 
-  ACE_DEBUG ((LM_DEBUG, "TIMER TEST ENDED\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "TIMER TEST ENDED\n"));
   return 0;
 }
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class Timer_Queue_Test_Driver <ACE_Timer_Heap, Input_Handler, Input_Handler::ACTION>;
-template class Command<Input_Handler, Input_Handler::ACTION>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate Timer_Queue_Test_Driver <ACE_Timer_Heap, Input_Handler, Input_Handler::ACTION>
-#pragma instantiate Command<Input_Handler, Input_Handler::ACTION>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/examples/Timer_Queue/Thread_Timer_Queue_Test.cpp b/examples/Timer_Queue/Thread_Timer_Queue_Test.cpp
index c224051cb61..e1a9644c808 100644
--- a/examples/Timer_Queue/Thread_Timer_Queue_Test.cpp
+++ b/examples/Timer_Queue/Thread_Timer_Queue_Test.cpp
@@ -13,7 +13,8 @@
 //      using an <ACE_Timer_Heap>.
 //
 // = AUTHORS
-//    Carlos O'Ryan and Douglas C. Schmidt
+//    Carlos O'Ryan <coryan@cs.wustl.edu> and
+//    Douglas C. Schmidt <schmidt@cs.wustl.edu>
 //
 // ============================================================================
 
@@ -23,6 +24,43 @@
 
 #include "Thread_Timer_Queue_Test.h"
 
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Thread_Timer_Queue_Adapter<Timer_Heap>;
+template class Timer_Queue_Test_Driver<Thread_Timer_Queue,
+                                       Input_Task,
+                                       Input_Task::ACTION>;
+template class Command<Input_Task, Input_Task::ACTION>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Thread_Timer_Queue_Adapter<Timer_Heap>
+#pragma instantiate Timer_Queue_Test_Driver<Thread_Timer_Queue, \
+                                           Input_Task, \
+                                           Input_Task::ACTION>
+#pragma instantiate Command<Input_Task, Input_Task::ACTION>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
+// These templates will specialized in libACE.* if the platforms does
+// not define ACE_MT_SAFE.
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Thread_Condition<ACE_Thread_Mutex>;
+template class ACE_Condition<ACE_Thread_Mutex>;
+template class ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>;
+template class ACE_Timer_Queue_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
+template class ACE_Timer_Heap_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
+template class ACE_Timer_Heap_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
+template class ACE_Timer_Queue_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Thread_Condition<ACE_Thread_Mutex>
+#pragma instantiate ACE_Condition<ACE_Thread_Mutex>
+#pragma instantiate ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>
+#pragma instantiate ACE_Timer_Queue_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
+#pragma instantiate ACE_Timer_Heap_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
+#pragma instantiate ACE_Timer_Heap_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
+#pragma instantiate ACE_Timer_Queue_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+#endif /* ACE_MT_SAFE */
+
 ACE_RCSID(Timer_Queue, Thread_Timer_Queue_Test, "$Id$")
 
 // Administrivia methods...
@@ -57,8 +95,8 @@ Handler::handle_timeout (const ACE_Time_Value &current_time,
                   this->id_,
                   current_time.sec (),
                   current_time.usec (),
-                  delay.sec (), delay.usec ());
-
+                  delay.sec (),
+                  delay.usec ());
   // Notice this delete is protected.
   delete this;
   return 0;
@@ -96,7 +134,8 @@ Input_Task::svc (void)
 
   // we are done.
   this->queue_->deactivate ();
-  ACE_DEBUG ((LM_DEBUG, "terminating input thread\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "terminating input thread\n"));
   return 0;
 }
 
@@ -106,13 +145,16 @@ Input_Task::svc (void)
 int
 Input_Task::add_timer (void *argument)
 {
-  u_long useconds = *(int *) argument;
-  ACE_Time_Value interval (useconds / usecs_, useconds % usecs_);
+  u_long useconds = *ACE_reinterpret_Cast (int *, argument);
+  ACE_Time_Value interval (useconds / usecs_,
+                           useconds % usecs_);
   ACE_Time_Value expire_at = ACE_OS::gettimeofday () + interval;
 
   Handler *h;
 
-  ACE_NEW_RETURN (h, Handler (expire_at), -1);
+  ACE_NEW_RETURN (h,
+                  Handler (expire_at),
+                  -1);
 
   int id = queue_->schedule (h, 0, expire_at);
 
@@ -125,7 +167,8 @@ Input_Task::add_timer (void *argument)
   // nicer messages.
   h->set_id (id);
 
-  ACE_OS::printf ("scheduling timer %d\n", id);
+  ACE_OS::printf ("scheduling timer %d\n",
+                  id);
   return 0;
 }
 
@@ -183,14 +226,16 @@ Input_Task::dump (void)
 {
   ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->queue_->mutex ());
 
-  ACE_DEBUG ((LM_DEBUG, "begin dumping timer queue\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "begin dumping timer queue\n"));
 
   for (Timer_Heap_Iterator i (this->queue_->timer_queue ());
        i.item () != 0;
        i.next ())
     i.item ()->dump ();
 
-  ACE_DEBUG ((LM_DEBUG, "end dumping timer queue\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "end dumping timer queue\n"));
 }
 
 // constructor
@@ -221,8 +266,9 @@ Thread_Timer_Queue_Test_Driver::display_menu (void)
     "3 : prints timer queue\n"
     "4 : exit\n";
 
-  ACE_DEBUG ((LM_DEBUG, "%s", menu));
-
+  ACE_DEBUG ((LM_DEBUG,
+              "%s",
+              menu));
   return 0;
 }
 
@@ -250,50 +296,16 @@ Thread_Timer_Queue_Test_Driver::init (void)
                   -1);
 
   if (this->input_task_.activate () == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "cannot activate input task"), -1);
-
-  if (this->timer_queue_.activate () == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "cannot activate timer queue"), -1);
-
-  if (ACE_Thread_Manager::instance ()->wait () == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "wait on Thread_Manager failed"),-1);
-
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "cannot activate input task"),
+                      -1);
+  else if (this->timer_queue_.activate () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "cannot activate timer queue"),
+                      -1);
+  else if (ACE_Thread_Manager::instance ()->wait () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "wait on Thread_Manager failed"),
+                      -1);
   return 0;
 }
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Thread_Timer_Queue_Adapter<Timer_Heap>;
-template class Timer_Queue_Test_Driver<Thread_Timer_Queue,
-                                       Input_Task,
-                                       Input_Task::ACTION>;
-template class Command<Input_Task, Input_Task::ACTION>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Thread_Timer_Queue_Adapter<Timer_Heap>
-#pragma instantiate Timer_Queue_Test_Driver<Thread_Timer_Queue, \
-                                           Input_Task, \
-                                           Input_Task::ACTION>
-#pragma instantiate Command<Input_Task, Input_Task::ACTION>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-// These templates will specialized in libACE.* if the platforms does
-// not define ACE_MT_SAFE.
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Thread_Condition<ACE_Thread_Mutex>;
-template class ACE_Condition<ACE_Thread_Mutex>;
-template class ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>;
-template class ACE_Timer_Queue_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
-template class ACE_Timer_Heap_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
-template class ACE_Timer_Heap_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
-template class ACE_Timer_Queue_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Thread_Condition<ACE_Thread_Mutex>
-#pragma instantiate ACE_Condition<ACE_Thread_Mutex>
-#pragma instantiate ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>
-#pragma instantiate ACE_Timer_Queue_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
-#pragma instantiate ACE_Timer_Heap_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
-#pragma instantiate ACE_Timer_Heap_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
-#pragma instantiate ACE_Timer_Queue_Iterator_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall<ACE_Null_Mutex>, ACE_Null_Mutex>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_MT_SAFE */