#include <ace/Timer_Heap_T.h>
template<class TYPE, class FUNCTOR, class ACE_LOCK> class ACE_Timer_Heap_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> {
public:typedef ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> HEAP_ITERATOR;friend class ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR, ACE_LOCK>;typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> INHERITED;ACE_Timer_Heap_T ( size_t size, int preallocated = 0, FUNCTOR *upcall_functor = 0, ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist = 0 );ACE_Timer_Heap_T ( FUNCTOR *upcall_functor = 0, ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist = 0 );virtual ~ACE_Timer_Heap_T (void);virtual int is_empty (void) const;virtual const ACE_Time_Value &earliest_time (void) const;virtual long schedule ( const TYPE &type, const void *act, const ACE_Time_Value &delay, const ACE_Time_Value &interval = ACE_Time_Value::zero );virtual int cancel ( const TYPE &type, int dont_call_handle_close = 1 );virtual int cancel ( long timer_id, const void **act = 0, int dont_call_handle_close = 1 );virtual ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> &iter ( void );ACE_Timer_Node_T <TYPE> *remove_first (void);virtual void dump (void) const;virtual ACE_Timer_Node_T<TYPE> *get_first (void);protected:virtual void reschedule (ACE_Timer_Node_T<TYPE> *);virtual ACE_Timer_Node_T<TYPE> *alloc_node (void);virtual void free_node (ACE_Timer_Node_T<TYPE> *);private:ACE_Timer_Node_T<TYPE> *remove (size_t index);void insert (ACE_Timer_Node_T<TYPE> *new_node);void grow_heap (void);void reheap_up ( ACE_Timer_Node_T<TYPE> *new_node, size_t index, size_t parent );void reheap_down ( ACE_Timer_Node_T<TYPE> *moved_node, size_t index, size_t child );void copy (int index, ACE_Timer_Node_T<TYPE> *moved_node);int timer_id (void);int pop_freelist (void);void push_freelist (int old_id);size_t max_size_;size_t cur_size_;HEAP_ITERATOR *iterator_;ACE_Timer_Node_T<TYPE> **heap_;long *timer_ids_;long timer_ids_freelist_;ACE_Timer_Node_T<TYPE> *preallocated_nodes_;ACE_Timer_Node_T<TYPE> *preallocated_nodes_freelist_;ACE_Unbounded_Set<ACE_Timer_Node_T<TYPE> *> preallocated_node_set_;inline ACE_UNIMPLEMENTED_FUNC ( ACE_Timer_Heap_T (const ACE_Timer_Heap_T<TYPE, FUNCTOR, ACE_LOCK> &) );};
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.
ACE_Timer_Heap_T (
    size_t size,
    int preallocated = 0,
    FUNCTOR *upcall_functor = 0,
    ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist = 0
    );
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.  This can also take in a
upcall functor and freelist (if 0, then defaults will be created)
ACE_Timer_Heap_T (
    FUNCTOR *upcall_functor = 0,
    ACE_Free_List<ACE_Timer_Node_T <TYPE> > *freelist = 0
    );
upcall_functor is the instance of the
FUNCTOR to be used by the queue. If upcall_functor is 0, Timer
Heap will create a default FUNCTOR.  freelist the freelist of
timer nodes.  If 0, then a default freelist will be created.  The default
size will be ACE_DEFAULT_TIMERS and there will be no preallocation.
virtual ~ACE_Timer_Heap_T (void);
virtual int is_empty (void) const;
virtual const ACE_Time_Value &earliest_time (void) const;
virtual long schedule (
    const TYPE &type,
    const void *act,
    const ACE_Time_Value &delay,
    const ACE_Time_Value &interval = ACE_Time_Value::zero
    );
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 (const TYPE &type, int dont_call_handle_close = 1);
type.  If dont_call is 0
then the functor will be invoked.  Returns number of timers
cancelled.
virtual int cancel (
    long timer_id,
    const void **act = 0,
    int dont_call_handle_close = 1
    );
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 ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> &iter (
    void
    );
ACE_Timer_Queue's iterator.
ACE_Timer_Node_T <TYPE> *remove_first (void);
virtual void dump (void) const;
virtual ACE_Timer_Node_T<TYPE> *get_first (void);
inline ACE_UNIMPLEMENTED_FUNC (
    ACE_Timer_Heap_T (const ACE_Timer_Heap_T<TYPE, FUNCTOR, ACE_LOCK> &)
    );