#include <ace/Timer_Heap.h>
class ACE_Timer_Heap : public ACE_Timer_Queue {
public:friend class ACE_Timer_Heap_Iterator;ACE_Timer_Heap ( size_t size = ACE_DEFAULT_TIMERS, int preallocated = 0 );virtual ~ACE_Timer_Heap (void);virtual int is_empty (void) const;virtual const ACE_Time_Value &earliest_time (void) const;virtual int schedule ( ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval = ACE_Time_Value::zero );virtual int cancel (ACE_Event_Handler *event_handler);virtual int cancel (int timer_id, const void **arg = 0);virtual void dump (void) const;protected:virtual void reschedule (ACE_Timer_Node *);virtual ACE_Timer_Queue_Iterator &iter (void);virtual ACE_Timer_Node *alloc_node (void);virtual void free_node (ACE_Timer_Node *);private:ACE_Timer_Node *remove (size_t index);void insert (ACE_Timer_Node *new_node);void grow_heap (void);void reheap_up (ACE_Timer_Node *new_node);void reheap_down (ACE_Timer_Node *moved_node, size_t child_index);int timer_id (void);int pop_freelist (void);void push_freelist (int old_id);size_t max_size_;size_t cur_size_;ACE_Timer_Heap_Iterator iterator_;ACE_Timer_Node **heap_;int *timer_ids_;int timer_ids_freelist_;ACE_Timer_Node *preallocated_nodes_;ACE_Timer_Node *preallocated_nodes_freelist_;ACE_Unbounded_Set<ACE_Timer_Node *> preallocated_node_set_;ACE_Timer_Heap (const ACE_Timer_Heap &);void operator= (const ACE_Timer_Heap &);};
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.
ACE_Timer_Heap (
size_t size = ACE_DEFAULT_TIMERS,
int preallocated = 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.
virtual ~ACE_Timer_Heap (void);
virtual int is_empty (void) const;
virtual const ACE_Time_Value &earliest_time (void) const;
virtual int schedule (
ACE_Event_Handler *event_handler,
const void *arg,
const ACE_Time_Value &delay,
const ACE_Time_Value &interval = ACE_Time_Value::zero
);
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
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);
event_handlers that match the address of
event_handler. Returns number of handler's cancelled.
virtual int cancel (int timer_id, const void **arg = 0);
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.
Returns 1 if cancellation succeeded and 0 if the timer_id
wasn't found.
virtual void dump (void) const;
ACE_Timer_Heap (const ACE_Timer_Heap &);
void operator= (const ACE_Timer_Heap &);