#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 slot);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 slot, size_t parent );void reheap_down ( ACE_Timer_Node_T<TYPE> *moved_node, size_t slot, size_t child );void copy (int slot, 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> &)
);