*** empty log message ***

1 files changed, 118 insertions, 83 deletions

diff --git a/ace/Timer_Queue.h b/ace/Timer_Queue.h
index 6c5fa062020..e46ce860b17 100644
--- a/ace/Timer_Queue.h
+++ b/ace/Timer_Queue.h
@@ -11,59 +11,76 @@
 //
 // = AUTHOR
 //    Doug Schmidt 
+//    Irfan Pyarali
 // 
 // ============================================================================
 
 #if !defined (ACE_TIMER_QUEUE_H)
 #define ACE_TIMER_QUEUE_H
 
-#include "ace/Event_Handler.h"
 #include "ace/Time_Value.h"
 #include "ace/Synch.h"
 
 // Forward declaration.
-class ACE_Timer_Queue;
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Queue_T;
+
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_List_T;
+
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_List_Iterator_T;
+
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Heap_T;
+
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Heap_Iterator_T;
 
 // This should be nested within the ACE_Timer_Queue class but some C++
 // compilers still don't like this...
 
-class ACE_Export ACE_Timer_Node
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Node_T
   // = TITLE
   //     Maintains the state associated with a Timer entry.
 {
   // = The use of friends should be replaced with accessors...
-  friend class ACE_Timer_Queue;
-  friend class ACE_Timer_List;
-  friend class ACE_Timer_List_Iterator;
-  friend class ACE_Timer_Heap;
-  friend class ACE_Timer_Heap_Iterator;
+  friend class ACE_Timer_Queue_T<TYPE, FUNCTOR>;
+  friend class ACE_Timer_List_T<TYPE, FUNCTOR>;
+  friend class ACE_Timer_List_Iterator_T<TYPE, FUNCTOR>;
+  friend class ACE_Timer_Heap_T<TYPE, FUNCTOR>;
+  friend class ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR>;
+  
+  typedef ACE_Timer_Node_T<TYPE, FUNCTOR> NODE;
+  // Typedef for self
 
   // = Initialization methods.
-  ACE_Timer_Node (ACE_Event_Handler *h, 
-		  const void *a, 
-		  const ACE_Time_Value &t, 
-		  const ACE_Time_Value &i, 
-		  ACE_Timer_Node *n, 
-		  int timer_id);
+  ACE_Timer_Node_T (const TYPE &type, 
+		    const void *a, 
+		    const ACE_Time_Value &t, 
+		    const ACE_Time_Value &i, 
+		    NODE *n, 
+		    int timer_id);
   // Constructor.
-
-  ACE_Timer_Node (void);
+  
+  ACE_Timer_Node_T (void);
   // Default constructor.
-
-  ACE_Event_Handler *handler_;
-  // Handler to invoke <handle_timeout> on when a timeout occurs.
-
-  const void *arg_;
-  // Argument to pass to <handle_timeout>.
-
+  
+  TYPE type_;
+  // Type of object stored in the Queue
+  
+  const void *act_;
+  // Act associated with the timer.
+  
   ACE_Time_Value timer_value_;
   // Time until the timer expires.
-
+  
   ACE_Time_Value interval_;
   // If this is a periodic timer this holds the time until the next
   // timeout.
 
-  ACE_Timer_Node *next_;
+  NODE *next_;
   // Pointer to next timer.
   
   int timer_id_;
@@ -73,10 +90,11 @@ class ACE_Export ACE_Timer_Node
   // Declare the dynamic allocation hooks.
 
   void dump (void) const;
-  // Dump the state of an object.
+  // Dump the state of an TYPE.
 };
 
-class ACE_Export ACE_Timer_Queue_Iterator
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Queue_Iterator_T
   // = TITLE
   //     Generic interfae for iterating over a subclass of
   //     <ACE_Timer_Queue>.
@@ -86,10 +104,14 @@ class ACE_Export ACE_Timer_Queue_Iterator
   //     the head of the timer queue up by one every time.
 {
 public:
-  ACE_Timer_Queue_Iterator (void);
-  virtual ~ACE_Timer_Queue_Iterator (void);
 
-  virtual int next (ACE_Timer_Node *&timer_node, 
+  typedef ACE_Timer_Node_T<TYPE, FUNCTOR> NODE;
+  // Type of the Node
+
+  ACE_Timer_Queue_Iterator_T (void);
+  virtual ~ACE_Timer_Queue_Iterator_T (void);
+
+  virtual int next (NODE *&timer_node, 
 		    const ACE_Time_Value &cur_time) = 0;
   // Pass back the next <timer_node> that hasn't been seen yet, if its
   // <time_value_> <= <cur_time>.  In addition, moves the timer queue
@@ -97,10 +119,8 @@ public:
   // seen, else 1.
 };
 
-// Forward declaration.
-class ACE_Upcall_Strategy;
-
-class ACE_Export ACE_Timer_Queue
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Queue_T
   // = TITLE 
   //      Provides an interface to timers.
   //
@@ -110,13 +130,19 @@ class ACE_Export ACE_Timer_Queue
   //      and <ACE_Timer_Heap>.
 {
 public: 
+  typedef ACE_Timer_Node_T<TYPE, FUNCTOR> NODE;
+  // Type of Node
+
+  typedef ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR> ITERATOR;
+  // Type of Iterator
+
   // = Initialization and termination methods.
-  ACE_Timer_Queue (ACE_Upcall_Strategy *upcall_strategy = 0);
-  // Default constructor. <expire> will call <upcall_strategy->upcall>
-  // if <upcall_strategy> is not 0. Else it will call <handle_timeout>
-  // on the <Event_Handler>
+  ACE_Timer_Queue_T (FUNCTOR *upcall_functor = 0);
+  // Default constructor. <upcall_functor> is the instance of the
+  // FUNCTOR to be used by the queue. If <upcall_functor> is 0, Timer
+  // Queue will create a default FUNCTOR.
 
-  virtual ~ACE_Timer_Queue (void);
+  virtual ~ACE_Timer_Queue_T (void);
   // Destructor - make virtual for proper destruction of inherited
   // classes.
 
@@ -126,54 +152,49 @@ public:
   virtual const ACE_Time_Value &earliest_time (void) const = 0;
   // Returns the time of the earlier node in the Timer_Queue.
 
-  virtual int schedule (ACE_Event_Handler *event_handler, 
-		        const void *arg, 
+  virtual int schedule (const TYPE &type, 
+		        const void *act, 
 		        const ACE_Time_Value &delay,
 		        const ACE_Time_Value &interval = ACE_Time_Value::zero) = 0;
-  // Schedule an <event_handler> that will expire after <delay> amount
-  // of time.  If it expires then <arg> is passed in as the value to
-  // the <event_handler>'s <handle_timeout> callback method.  If
-  // <interval> is != to <ACE_Time_Value::zero> then it is used to
-  // reschedule the <event_handler> automatically.  This method
-  // returns a <timer_id> that uniquely identifies the <event_handler>
-  // in an internal list.  This <timer_id> can be used to cancel an
-  // <event_handler> before it expires.  The cancellation ensures that
+  // Schedule <type> that will expire after <delay> amount of time.
+  // If it expires then <act> is passed in as the value to the
+  // <functor>.  If <interval> is != to <ACE_Time_Value::zero> then it
+  // is used to reschedule the <type> automatically.  This method
+  // returns a <timer_id> that uniquely identifies the the <type>
+  // entry in an internal list.  This <timer_id> can be used to cancel
+  // the timer before it expires.  The cancellation ensures that
   // <timer_ids> are unique up to values of greater than 2 billion
   // timers.  As long as timers don't stay around longer than this
   // there should be no problems with accidentally deleting the wrong
   // timer.  Returns -1 on failure (which is guaranteed never to be a
   // valid <timer_id>).
 
-  virtual int cancel (ACE_Event_Handler *event_handler,
+  virtual int cancel (const TYPE &type,
 		      int dont_call_handle_close = 1) = 0;
-  // Cancel all <event_handlers> that match the address of
-  // <event_handler>.  If <dont_call_handle_close> is 0 then the
-  // <handle_close> method of <event_handler> will be invoked.
-  // Returns number of handler's cancelled.
+  // Cancel all timer associated with <type>.  If <dont_call> is 0
+  // then the <functor> will be invoked.  Returns number of timers
+  // cancelled.
 
   virtual int cancel (int timer_id, 
-		      const void **arg = 0,
+		      const void **act = 0,
 		      int dont_call_handle_close = 1) = 0;
-  // Cancel the single <ACE_Event_Handler> that matches the <timer_id>
-  // value (which was returned from the <schedule> method).  If arg is
-  // non-NULL then it will be set to point to the ``magic cookie''
-  // argument passed in when the <Event_Handler> was registered.  This
-  // makes it possible to free up the memory and avoid memory leaks.
-  // If <dont_call_handle_close> is 0 then the <handle_close> method
-  // of <event_handler> will be invoked.  Returns 1 if cancellation
+  // Cancel the single timer that matches the <timer_id> value (which
+  // was returned from the <schedule> method).  If act is non-NULL
+  // then it will be set to point to the ``magic cookie'' argument
+  // passed in when the timer was registered.  This makes it possible
+  // to free up the memory and avoid memory leaks.  If <dont_call> is
+  // 0 then the <functor> will be invoked.  Returns 1 if cancellation
   // succeeded and 0 if the <timer_id> wasn't found.
 
   virtual int expire (const ACE_Time_Value &current_time);
-  // Run the <handle_timeout> method for all Timers whose values are
-  // <= <cur_time>.  This does not account for <timer_skew>.  Returns
-  // the number of <Event_Handler>s for which <handle_timeout> was
-  // called.
+  // Run the <functor> for all timers whose values are <= <cur_time>.
+  // This does not account for <timer_skew>.  Returns the number of
+  // timers canceled.
 
   virtual int expire (void);
-  // Run the <handle_timeout> method for all Timers whose values are
-  // <= <ACE_OS::gettimeofday>.  Also accounts for <timer_skew>.
-  // Returns the number of <Event_Handler>s for which <handle_timeout>
-  // was called.
+  // Run the <functor> for all timers whose values are <=
+  // <ACE_OS::gettimeofday>.  Also accounts for <timer_skew>.  Returns
+  // the number of timers canceled.
 
   virtual ACE_Time_Value gettimeofday (void);
   // Returns the current time of day.  This allows different
@@ -197,30 +218,33 @@ public:
   // Synchronization variable used by the queue
 #endif /* ACE_MT_SAFE */
 
+  FUNCTOR &upcall_functor (void);
+  // Accessor to the upcall functor
+
   virtual void dump (void) const;
-  // Dump the state of an object.
+  // Dump the state of a object.
 
   ACE_ALLOC_HOOK_DECLARE;
   // Declare the dynamic allocation hooks.
 
 protected:
 
-  virtual void upcall (ACE_Event_Handler *handler,
-		       const void *arg,
+  virtual void upcall (TYPE &type,
+		       const void *act,
 		       const ACE_Time_Value &cur_time);
-  // This method will call <handle_timeout> on the <handler> or will
-  // forward the parameters to an upcall strategy (if one is present)
+  // This method will call the <functor> with the <type>, <act> and
+  // <time>
 
-  virtual void reschedule (ACE_Timer_Node *) = 0;
+  virtual void reschedule (NODE *) = 0;
   // Reschedule an "interval" <ACE_Timer_Node>.
 
-  virtual ACE_Timer_Queue_Iterator &iter (void) = 0;
+  virtual ITERATOR &iter (void) = 0;
   // Returns a pointer to this <ACE_Timer_Queue>'s iterator.
 
-  virtual ACE_Timer_Node *alloc_node (void) = 0;
+  virtual NODE *alloc_node (void) = 0;
   // Factory method that allocates a new node.
 
-  virtual void free_node (ACE_Timer_Node *) = 0;
+  virtual void free_node (NODE *) = 0;
   // Factory method that frees a previously allocated node.
 
 #if defined (ACE_MT_SAFE)
@@ -231,8 +255,11 @@ protected:
   ACE_Time_Value (*gettimeofday_)(void);
   // Pointer to function that returns the current time of day.
 
-  ACE_Upcall_Strategy *upcall_strategy_;
-  // Upcall Strategy for callbacks
+  FUNCTOR &upcall_functor_;
+  // Upcall functor
+
+  int delete_upcall_functor_;
+  // To delete or not to delete is the question?
 
 private:
   ACE_Time_Value timeout_;
@@ -242,12 +269,20 @@ private:
   // Adjusts for timer skew in various clocks.
 
   // = Don't allow these operations for now.
-  ACE_Timer_Queue (const ACE_Timer_Queue &);
-  void operator= (const ACE_Timer_Queue &);
+  ACE_Timer_Queue_T (const ACE_Timer_Queue_T<TYPE, FUNCTOR> &);
+  void operator= (const ACE_Timer_Queue_T<TYPE, FUNCTOR> &);
 };
 
 #if defined (__ACE_INLINE__)
 #include "ace/Timer_Queue.i"
 #endif /* __ACE_INLINE__ */
 
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "ace/Timer_Queue.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Timer_Queue.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
 #endif /* ACE_TIMER_QUEUE_H */