ChangeLogTag: Thu May 22 14:13:37 2003 Irfan Pyarali <irfan@oomworks.com>Reactor_RefCount_1

1 files changed, 133 insertions, 32 deletions

diff --git a/ace/Timer_Queue_T.cpp b/ace/Timer_Queue_T.cpp
index 9d77576261c..44ce2d61121 100644
--- a/ace/Timer_Queue_T.cpp
+++ b/ace/Timer_Queue_T.cpp
@@ -12,6 +12,7 @@
 #include "ace/Signal.h"
 #include "ace/Timer_Queue_T.h"
 #include "ace/Log_Msg.h"
+#include "ace/Reactor_Timer_Interface.h"
 
 #if !defined (__ACE_INLINE__)
 #include "ace/Timer_Queue_T.i"
@@ -45,8 +46,6 @@ ACE_Timer_Node_T<TYPE>::~ACE_Timer_Node_T (void)
   ACE_TRACE ("ACE_Timer_Node_T::~ACE_Timer_Node_T");
 }
 
-
-
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK>::ACE_Timer_Queue_Iterator_T (void)
 {
@@ -201,6 +200,33 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::mutex (void)
   return this->mutex_;
 }
 
+template <class TYPE, class FUNCTOR, class ACE_LOCK> long
+ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::schedule (const TYPE &type,
+                                                      const void *act,
+                                                      const ACE_Time_Value &future_time,
+                                                      const ACE_Time_Value &interval)
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
+
+  // Schedule the timer.
+  int result =
+    this->schedule_i (type,
+                      act,
+                      future_time,
+                      interval);
+
+  // Return on failure.
+  if (result == -1)
+    return result;
+
+  // Inform upcall functor of successful registration.
+  this->upcall_functor ().registration (*this,
+                                        type,
+                                        act);
+
+  // Return result;
+  return result;
+}
 
 // Run the <handle_timeout> method for all Timers whose values are <=
 // <cur_time>.
@@ -224,8 +250,13 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::expire (const ACE_Time_Value &cur_ti
   while ((result = this->dispatch_info_i (cur_time,
                                           info)) != 0)
     {
-      // call the functor
-      this->upcall (info.type_, info.act_, cur_time);
+      const void *upcall_act = 0;
+
+      this->preinvoke (info, cur_time, upcall_act);
+
+      this->upcall (info, cur_time);
+
+      this->postinvoke (info, cur_time, upcall_act);
 
       number_of_timers_expired++;
 
@@ -235,7 +266,6 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::expire (const ACE_Time_Value &cur_ti
   return number_of_timers_expired;
 }
 
-
 template <class TYPE, class FUNCTOR, class ACE_LOCK> int
 ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::dispatch_info_i (const ACE_Time_Value &cur_time,
                                                              ACE_Timer_Node_Dispatch_Info_T<TYPE> &info)
@@ -260,7 +290,8 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::dispatch_info_i (const ACE_Time_Valu
           // Make sure that we skip past values that have already
           // "expired".
           do
-            expired->set_timer_value (expired->get_timer_value () + expired->get_interval ());
+            expired->set_timer_value (expired->get_timer_value () +
+                                      expired->get_interval ());
           while (expired->get_timer_value () <= cur_time);
 
           // Since this is an interval timer, we need to reschedule
@@ -279,7 +310,6 @@ ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::dispatch_info_i (const ACE_Time_Valu
   return 0;
 }
 
-
 template <class TYPE, class FUNCTOR, class ACE_LOCK> void
 ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>::return_node (ACE_Timer_Node_T<TYPE> *node)
 {
@@ -299,51 +329,122 @@ ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::~ACE_Event_Handler_Handle_Tim
 }
 
 template <class ACE_LOCK> int
+ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::registration (TIMER_QUEUE &,
+                                                                 ACE_Event_Handler *event_handler,
+                                                                 const void *)
+{
+  int requires_reference_counting =
+    event_handler->reference_counting_policy ().value () ==
+    ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
+
+  if (requires_reference_counting)
+    {
+      event_handler->add_reference ();
+    }
+
+  return 0;
+}
+
+template <class ACE_LOCK> int
+ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::preinvoke (TIMER_QUEUE & /* timer_queue */,
+                                                              ACE_Event_Handler *event_handler,
+                                                              const void * /* timer_act */,
+                                                              int /* recurring_timer */,
+                                                              const ACE_Time_Value & /* cur_time */,
+                                                              const void *&upcall_act)
+{
+  int requires_reference_counting =
+    event_handler->reference_counting_policy ().value () ==
+    ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
+
+  if (requires_reference_counting)
+    {
+      event_handler->add_reference ();
+
+      upcall_act = &this->requires_reference_counting_;
+    }
+
+  return 0;
+}
+
+template <class ACE_LOCK> int
+ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::postinvoke (TIMER_QUEUE & /* timer_queue */,
+                                                               ACE_Event_Handler *event_handler,
+                                                               const void * /* timer_act */,
+                                                               int /* recurring_timer */,
+                                                               const ACE_Time_Value & /* cur_time */,
+                                                               const void *upcall_act)
+{
+  if (upcall_act == &this->requires_reference_counting_)
+    {
+      event_handler->remove_reference ();
+    }
+
+  return 0;
+}
+
+template <class ACE_LOCK> int
 ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::timeout (TIMER_QUEUE &timer_queue,
-                                                            ACE_Event_Handler *handler,
+                                                            ACE_Event_Handler *event_handler,
                                                             const void *act,
+                                                            int recurring_timer,
                                                             const ACE_Time_Value &cur_time)
 {
-  // Upcall to the <handler>s handle_timeout() method.
-  if (handler->handle_timeout (cur_time, act) == -1)
+  int requires_reference_counting = 0;
+
+  if (!recurring_timer)
     {
-#if 0
-      // Commented out until we figure out how to break the coupling that results...
-      if (handler->reactor ())
-        // Call the reactor's cancel_timer() method to minimize locking.
-        handler->reactor ()->cancel_timer (handler, 0); // 0 means "call handle_close()".
+      requires_reference_counting =
+        event_handler->reference_counting_policy ().value () ==
+        ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
+    }
+
+  // Upcall to the <handler>s handle_timeout method.
+  if (event_handler->handle_timeout (cur_time, act) == -1)
+    {
+      if (event_handler->reactor ())
+        event_handler->reactor_timer_interface ()->cancel_timer (event_handler, 0);
       else
-#endif
-        timer_queue.cancel (handler, 0); 
+        timer_queue.cancel (event_handler, 0); // 0 means "call handle_close()".
+    }
+
+  if (!recurring_timer &&
+      requires_reference_counting)
+    {
+      event_handler->remove_reference ();
     }
 
   return 0;
 }
 
 template <class ACE_LOCK> int
-ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::cancellation (TIMER_QUEUE &timer_queue,
-                                                                 ACE_Event_Handler *handler)
+ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::cancellation (TIMER_QUEUE &,
+                                                                 ACE_Event_Handler *event_handler,
+                                                                 int dont_call)
 {
-  ACE_UNUSED_ARG (timer_queue);
+  int requires_reference_counting =
+    event_handler->reference_counting_policy ().value () ==
+    ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
 
   // Upcall to the <handler>s handle_close method
-  handler->handle_close (ACE_INVALID_HANDLE,
-                         ACE_Event_Handler::TIMER_MASK);
+  if (dont_call == 0)
+    event_handler->handle_close (ACE_INVALID_HANDLE,
+                                 ACE_Event_Handler::TIMER_MASK);
+
+  if (requires_reference_counting)
+    event_handler->remove_reference ();
+
   return 0;
 }
 
 template <class ACE_LOCK> int
 ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>::deletion (TIMER_QUEUE &timer_queue,
-                                                             ACE_Event_Handler *handler,
-                                                             const void *arg)
+                                                             ACE_Event_Handler *event_handler,
+                                                             const void *)
 {
-  ACE_UNUSED_ARG (timer_queue);
-  ACE_UNUSED_ARG (handler);
-  ACE_UNUSED_ARG (arg);
-
-  // Does nothing
-
-  return 0;
+  return this->cancellation (timer_queue,
+                             event_handler,
+                             0);
 }
 
-#endif /* ACE_TIMER_QUEUE_T_C*/
+#endif /* ACE_TIMER_QUEUE_T_C */