#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