#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 &);