From 34a82afb8e57608987736008005af93b310a1417 Mon Sep 17 00:00:00 2001 From: irfan Date: Fri, 25 Apr 1997 07:20:29 +0000 Subject: *** empty log message *** --- ace/Timer_Heap.h | 130 ++++++++++++++++++++++++++++++------------------------- 1 file changed, 70 insertions(+), 60 deletions(-) (limited to 'ace/Timer_Heap.h') 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 ACE_Timer_Heap_T; -class ACE_Export ACE_Timer_Heap_Iterator : public ACE_Timer_Queue_Iterator +template +class ACE_Timer_Heap_Iterator_T : public ACE_Timer_Queue_Iterator_T // = TITLE // Iterates over an . // @@ -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 &); // 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 that hasn't been seen yet, if its // <= . In addition, moves the timer queue @@ -43,40 +45,43 @@ public: // seen, else 1. protected: - ACE_Timer_Heap &timer_heap_; + ACE_Timer_Heap_T &timer_heap_; // Pointer to the that we are iterating over. }; -// Forward declaration. -class ACE_Upcall_Strategy; - -class ACE_Export ACE_Timer_Heap : public ACE_Timer_Queue +template +class ACE_Timer_Heap_T : public ACE_Timer_Queue_T // = 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 - // timers is O(log N) (where N is the total number of timers). - // In addition, we can also preallocate as many - // 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 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 HEAP_ITERATOR; + friend HEAP_ITERATOR; + + typedef ACE_Timer_Queue_T 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 elements. If // is non-0 then we'll pre-allocate all the memory // for the . 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 that will expire after amount - // of time. If it expires then is passed in as the value to - // the 's callback method. If - // is != to then it is used to - // reschedule the automatically. This method - // returns a that uniquely identifies the - // in an internal list. This can be used to cancel an - // before it expires. The cancellation ensures that + // Schedule that will expire after amount of time. + // If it expires then is passed in as the value to the + // . If is != to then it + // is used to reschedule the automatically. This method + // returns a that uniquely identifies the the + // entry in an internal list. This can be used to cancel + // the timer before it expires. The cancellation ensures that // 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 . + // valid ). - virtual int cancel (ACE_Event_Handler *event_handler, + virtual int cancel (const TYPE &type, int dont_call_handle_close = 1); - // Cancel all that match the address of - // . If is 0 then the - // method of will be invoked. - // Returns number of handler's cancelled. + // Cancel all timer associated with . If is 0 + // then the 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 that matches the - // value (which was returned from the method). If arg is - // non-NULL then it will be set to point to the ``magic cookie'' - // argument passed in when the was registered. This - // makes it possible to free up the memory and avoid memory leaks. - // If is 0 then the method - // of will be invoked. Returns 1 if cancellation + // Cancel the single timer that matches the value (which + // was returned from the 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 is + // 0 then the will be invoked. Returns 1 if cancellation // succeeded and 0 if the 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" . - virtual ACE_Timer_Queue_Iterator &iter (void); + virtual ITERATOR &iter (void); // Returns a pointer to this '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 th and restore the // heap property. - void insert (ACE_Timer_Node *new_node); + void insert (NODE *new_node); // Insert 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 . - 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 . - void copy (int index, ACE_Timer_Node *moved_node); + void copy (int index, NODE *moved_node); // Copy into the slot of and move // into the corresponding slot in the 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 // *'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 array, which is organized as a stack. - ACE_Timer_Node *preallocated_nodes_; + NODE *preallocated_nodes_; // If this is non-0, then we preallocate number of // 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 freelist, // which is organized as a stack. - ACE_Unbounded_Set preallocated_node_set_; + ACE_Unbounded_Set 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 &); + void operator= (const ACE_Timer_Heap_T &); }; +#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 */ -- cgit v1.2.1