| ACE 8.0.1
    | 
Provides a simple implementation of timers. More...
#include <Timer_List_T.h>


| Public Types | |
| typedef ACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Iterator | 
| Type of iterator. | |
| typedef ACE_Timer_Node_T< TYPE > | Node | 
| typedef ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | Base_Timer_Queue | 
| Type inherited from. | |
| typedef ACE_Free_List< Node > | FreeList | 
|  Public Types inherited from ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | |
| typedef TIME_POLICY | time_policy_t | 
| Type of time policy. | |
|  Public Types inherited from ACE_Abstract_Timer_Queue< TYPE > | |
| typedef ACE_Timer_Queue_Iterator_T< TYPE > | ITERATOR | 
| Type of Iterator. | |
| Private Member Functions | |
| virtual long | schedule_i (const TYPE &type, const void *act, const ACE_Time_Value &future_time, const ACE_Time_Value &interval) | 
| void | schedule_i (ACE_Timer_Node_T< TYPE > *n, const ACE_Time_Value &exp) | 
| The shared scheduling functionality between schedule() and reschedule() | |
| ACE_Timer_Node_T< TYPE > * | find_node (long timer_id) const | 
| void | cancel_i (ACE_Timer_Node_T< TYPE > *n) | 
| Shared subset of the two cancel() methods. | |
| void | unlink (ACE_Timer_Node_T< TYPE > *n) | 
| ACE_Timer_Node_T< TYPE > * | get_first_i () const | 
| ACE_Timer_List_T (const ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK > &)=delete | |
| void | operator= (const ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK > &)=delete | 
| Private Attributes | |
| ACE_Timer_Node_T< TYPE > * | head_ | 
| Pointer to linked list of <ACE_Timer_Handles>. | |
| Iterator * | iterator_ | 
| Iterator used to expire timers. | |
| long | id_counter_ | 
| Friends | |
| class | ACE_Timer_List_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | 
| Iterator is a friend. | |
| Additional Inherited Members | |
|  Protected Member Functions inherited from ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | |
| virtual ACE_Timer_Node_T< TYPE > * | alloc_node () | 
| Factory method that allocates a new node. | |
| virtual void | free_node (ACE_Timer_Node_T< TYPE > *) | 
| Factory method that frees a previously allocated node. | |
| virtual int | dispatch_info_i (const ACE_Time_Value ¤t_time, ACE_Timer_Node_Dispatch_Info_T< TYPE > &info) | 
| Non-locking version of dispatch_info () | |
| void | recompute_next_abs_interval_time (ACE_Timer_Node_T< TYPE > *expired, const ACE_Time_Value &cur_time) | 
| Recompute when the next time is that this interval timer should fire. | |
|  Protected Attributes inherited from ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY > | |
| ACE_LOCK | mutex_ | 
| ACE_Free_List< ACE_Timer_Node_T< TYPE > > * | free_list_ | 
| Class that implements a free list. | |
| TIME_POLICY | time_policy_ | 
| The policy to return the current time of day. | |
| bool const | delete_free_list_ | 
| Flag to delete only if the class created the <free_list_> | |
|  Protected Attributes inherited from ACE_Timer_Queue_Upcall_Base< TYPE, FUNCTOR > | |
| FUNCTOR * | upcall_functor_ | 
| Upcall functor. | |
| bool const | delete_upcall_functor_ | 
| To delete or not to delete is the question? | |
Provides a simple implementation of timers.
This implementation uses a linked list of absolute times. Therefore, in the average case, scheduling and canceling 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.
| typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY> ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >::Base_Timer_Queue | 
Type inherited from.
| typedef ACE_Free_List<Node> ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >::FreeList | 
| typedef ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY> ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >::Iterator | 
Type of iterator.
| typedef ACE_Timer_Node_T<TYPE> ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >::Node | 
| ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >::ACE_Timer_List_T | ( | FUNCTOR * | upcall_functor = 0, | 
| FreeList * | freelist = 0, | ||
| TIME_POLICY const & | time_policy = TIME_POLICY() ) | 
Default constructor. upcall_functor is the instance of the FUNCTOR to be used by the list. If upcall_functor is 0, a default FUNCTOR will be created. freelist is the freelist of timer nodes. If 0, then a default freelist will be created.
| 
 | virtual | 
Destructor.
| 
 | privatedelete | 
| 
 | virtual | 
Cancel all timers associated with type. If dont_call_handle_close is 0 then the functor will be invoked. Returns the number of timers cancelled.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | virtual | 
Cancel the single timer that matches the 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.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | private | 
Shared subset of the two cancel() methods.
| 
 | virtual | 
Destroy timer queue. Cancels all timers.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | virtual | 
Dump the state of an object.
Reimplemented from ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >.
| 
 | virtual | 
Returns the time of the earlier node in the ACE_Timer_List. Must be called on a non-empty queue.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | private | 
| 
 | virtual | 
Reads the earliest node from the queue and returns it.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | private | 
| 
 | virtual | 
True if queue is empty, else false.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | virtual | 
Returns a pointer to this ACE_Timer_Queue's iterator.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | privatedelete | 
| 
 | virtual | 
Removes the earliest node from the queue and returns it.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | virtual | 
Reschedule an "interval" ACE_Timer_Node_T. This should be private but for now it needs to be public for <ACE_Timer_Hash_T>
Implements ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >.
| 
 | virtual | 
Resets the interval of the timer represented by timer_id to interval, which is specified in relative time to the current <gettimeofday>. If interval is equal to ACE_Time_Value::zero, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not.
Implements ACE_Abstract_Timer_Queue< TYPE >.
| 
 | private | 
The shared scheduling functionality between schedule() and reschedule()
| 
 | privatevirtual | 
Schedule type that will expire at future_time, which is specified in absolute 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, using relative time to the current <gettimeofday>. 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>).
Implements ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY >.
| 
 | private | 
| 
 | friend | 
Iterator is a friend.
| 
 | private | 
Pointer to linked list of <ACE_Timer_Handles>.
| 
 | private | 
Keeps track of the timer id that uniquely identifies each timer. This id can be used to cancel a timer via the <cancel(long)> method.
| 
 | private | 
Iterator used to expire timers.