#include <ace/Timer_List.h>
class ACE_Timer_List : public ACE_Timer_Queue {
public:
friend class ACE_Timer_List_Iterator;
ACE_Timer_List (void);
virtual ~ACE_Timer_List (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 ACE_Timer_Node *alloc_node (void);
virtual void free_node (ACE_Timer_Node *);
private:
int timer_id (void);
virtual void reschedule (ACE_Timer_Node *);
virtual ACE_Timer_Queue_Iterator &iter (void);
ACE_Timer_Node *head_;
ACE_Timer_List_Iterator iterator_;
int timer_id_;
ACE_Timer_List (const ACE_Timer_List &);
void operator= (const ACE_Timer_List &);
};
ACE_Event_Handler
timers is O(N) (where N is the total
number of timers) and expiring timers is O(K) (where K is
the total number of timers that are the current time of
day).
More clever implementations could use a delta-list, a heap,
or timing wheels, etc. For instance, ACE_Timer_Heap
is a subclass of ACE_Timer_List
that implements a
heap-based callout queue. For most applications, the
ACE_Timer_Heap
will perform substantially faster than the
ACE_Timer_List
.
Initialization and termination methods.
ACE_Timer_List (void);
Default constructor.
virtual ~ACE_Timer_List (void);
Destructor
virtual int is_empty (void) const;
True if queue is empty, else false.
virtual const ACE_Time_Value &earliest_time (void) const;
Returns the time of the earlier node in the ACE_Timer_List
.
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
);
Schedule an 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);
Cancel all 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);
Cancel the single 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;
Dump the state of an object.
Don't allow these operations for now.
ACE_Timer_List (const ACE_Timer_List &);
void operator= (const ACE_Timer_List &);
AUTHOR
Doug Schmidt
TITLE
Provides a simple implementation of timers.
LIBRARY
ace