*** empty log message ***

1 files changed, 70 insertions, 60 deletions

diff --git a/ace/Timer_Heap.h b/ace/Timer_Heap.h
index aa499ec79ed..b037fc092f3 100644
--- a/ace/Timer_Heap.h
+++ b/ace/Timer_Heap.h
@@ -21,9 +21,11 @@
 #include "ace/Set.h"
 
 // Forward declaration
-class ACE_Timer_Heap;
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Heap_T;
 
-class ACE_Export ACE_Timer_Heap_Iterator : public ACE_Timer_Queue_Iterator
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Heap_Iterator_T : public ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR> 
   // = TITLE
   //     Iterates over an <ACE_Timer_Queue>.
   //
@@ -32,10 +34,10 @@ class ACE_Export ACE_Timer_Heap_Iterator : public ACE_Timer_Queue_Iterator
   //     the head of the timer queue up by one every time.
 {
 public:
-  ACE_Timer_Heap_Iterator (ACE_Timer_Heap &);
+  ACE_Timer_Heap_Iterator_T (ACE_Timer_Heap_T<TYPE, FUNCTOR> &);
   // Constructor.
 
-  virtual int next (ACE_Timer_Node *&timer_node, 
+  virtual int next (NODE *&timer_node, 
 		    const ACE_Time_Value &cur_time);
   // Pass back the next <timer_node> that hasn't been seen yet, if its
   // <time_value_> <= <cur_time>.  In addition, moves the timer queue
@@ -43,40 +45,43 @@ public:
   // seen, else 1.
 
 protected:
-  ACE_Timer_Heap &timer_heap_;
+  ACE_Timer_Heap_T<TYPE, FUNCTOR> &timer_heap_;
   // Pointer to the <ACE_Timer_Heap> that we are iterating over.
 };
 
-// Forward declaration.
-class ACE_Upcall_Strategy;
-
-class ACE_Export ACE_Timer_Heap : public ACE_Timer_Queue
+template <class TYPE, class FUNCTOR>
+class ACE_Timer_Heap_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR>
   // = TITLE 
   //      Provides a very fast and predictable timer implementation.
   //
   // = DESCRIPTION
+  //
   //      This implementation uses a heap-based callout queue of
   //      absolute times.  Therefore, in the average and worst case,
-  //      scheduling, canceling, and expiring <ACE_Event_Handler>
-  //      timers is O(log N) (where N is the total number of timers).
-  //      In addition, we can also preallocate as many <ACE_Timer_Nodes>
-  //      as there are slots in the heap.  This allows us to
-  //      completely remove the need for dynamic memory allocation,
-  //      which is important for real-time systems.
+  //      scheduling, canceling, and expiring timers is O(log N) (where
+  //      N is the total number of timers).  In addition, we can also
+  //      preallocate as many <ACE_Timer_Nodes> as there are slots in
+  //      the heap.  This allows us to completely remove the need for
+  //      dynamic memory allocation, which is important for real-time
+  //      systems.
 {
-  friend class ACE_Timer_Heap_Iterator;
 public:
+  typedef ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR> HEAP_ITERATOR;
+  friend HEAP_ITERATOR;
+
+  typedef ACE_Timer_Queue_T<TYPE, FUNCTOR> INHERITED;
+
   // = Initialization and termination methods.
-  ACE_Timer_Heap (size_t size = ACE_DEFAULT_TIMERS,
-		  int preallocated = 0,
-		  ACE_Upcall_Strategy *upcall_strategy = 0);
+  ACE_Timer_Heap_T (size_t size = ACE_DEFAULT_TIMERS,
+		    int preallocated = 0,
+		    FUNCTOR *upcall_functor = 0);
   // The Constructor creates a heap with <size> elements.  If
   // <preallocated> is non-0 then we'll pre-allocate all the memory
   // for the <ACE_Timer_Nodes>.  This saves time and is more
   // predictable (though it requires more space).  Otherwise, we'll
   // just allocate the nodes as we need them.
 
-  virtual ~ACE_Timer_Heap (void);
+  virtual ~ACE_Timer_Heap_T (void);
   // Destructor.
 
   virtual int is_empty (void) const;
@@ -85,68 +90,65 @@ public:
   virtual const ACE_Time_Value &earliest_time (void) const;
   // 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);
-  // 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>.
+  // valid <timer_id>).
 
-  virtual int cancel (ACE_Event_Handler *event_handler,
+  virtual int cancel (const TYPE &type,
 		      int dont_call_handle_close = 1);
-  // 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);
-  // 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 void dump (void) const;
   // Dump the state of an object.
 
 protected:
-  virtual void reschedule (ACE_Timer_Node *);
+  virtual void reschedule (NODE *);
   // Reschedule an "interval" <ACE_Timer_Node>.
 
-  virtual ACE_Timer_Queue_Iterator &iter (void);
+  virtual ITERATOR &iter (void);
   // Returns a pointer to this <ACE_Timer_Queue>'s iterator.
 
-  virtual ACE_Timer_Node *alloc_node (void);
+  virtual NODE *alloc_node (void);
   // Factory method that allocates a new node (uses operator new if
   // we're *not* preallocating, otherwise uses an internal freelist).
 
-  virtual void free_node (ACE_Timer_Node *);
+  virtual void free_node (NODE *);
   // Factory method that frees a previously allocated node (uses
   // operatord delete if we're *not* preallocating, otherwise uses an
   // internal freelist).
 
 private:
-  ACE_Timer_Node *remove (size_t index);
+  NODE *remove (size_t index);
   // Remove and return the <index>th <ACE_Timer_Node> and restore the
   // heap property.
 
-  void insert (ACE_Timer_Node *new_node);
+  void insert (NODE *new_node);
   // Insert <new_node> into the heap and restore the heap property.
 
   void grow_heap (void);
@@ -154,17 +156,17 @@ private:
   // If preallocation is used, will also double the size of the 
   // preallocated array of ACE_Timer_Nodes.
 
-  void reheap_up (ACE_Timer_Node *new_node, 
+  void reheap_up (NODE *new_node, 
 		  size_t index,
 		  size_t parent);
   // Restore the heap property, starting at <index>.
 
-  void reheap_down (ACE_Timer_Node *moved_node, 
+  void reheap_down (NODE *moved_node, 
 		    size_t index, 
 		    size_t child);
   // Restore the heap property, starting at <index>.
 
-  void copy (int index, ACE_Timer_Node *moved_node);
+  void copy (int index, NODE *moved_node);
   // Copy <moved_node> into the <index> slot of <heap_> and move
   // <index> into the corresponding slot in the <timer_id_> array.
 
@@ -186,10 +188,10 @@ private:
   size_t cur_size_;
   // Current size of the heap.
   
-  ACE_Timer_Heap_Iterator iterator_;
+  HEAP_ITERATOR iterator_;
   // Iterator used to expire timers.
 
-  ACE_Timer_Node **heap_;
+  NODE **heap_;
   // Current contents of the Heap, which is organized as a "heap" of
   // <ACE_Timer_Node> *'s.  In this context, a heap is a "partially
   // ordered, almost complete" binary tree, which is stored in an
@@ -209,23 +211,31 @@ private:
   // "Pointer" to the first element in the freelist contained within
   // the <timer_ids_> array, which is organized as a stack.
 
-  ACE_Timer_Node *preallocated_nodes_;
+  NODE *preallocated_nodes_;
   // If this is non-0, then we preallocate <max_size_> number of
   // <ACE_Timer_Node> objects in order to reduce dynamic allocation
   // costs.  In auto-growing implementation, this points to the 
   // last array of nodes allocated.
 
-  ACE_Timer_Node *preallocated_nodes_freelist_;
+  NODE *preallocated_nodes_freelist_;
   // This points to the head of the <preallocated_nodes_> freelist,
   // which is organized as a stack.
 
-  ACE_Unbounded_Set<ACE_Timer_Node *> preallocated_node_set_;
+  ACE_Unbounded_Set<NODE *> preallocated_node_set_;
   // Set of pointers to the arrays of preallocated timer nodes.
   // Used to delete the allocated memory when required.
 
   // = Don't allow these operations for now.
-  ACE_Timer_Heap (const ACE_Timer_Heap &);
-  void operator= (const ACE_Timer_Heap &);
+  ACE_Timer_Heap_T (const ACE_Timer_Heap_T<TYPE, FUNCTOR> &);
+  void operator= (const ACE_Timer_Heap_T<TYPE, FUNCTOR> &);
 };
 
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "ace/Timer_Heap.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Timer_Heap.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
 #endif /* ACE_TIMER_HEAP_H */