ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > Class Template Reference

Provides an interface to timers. More...

#include <Timer_Queue_T.h>

Inheritance diagram for ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_Timer_Queue_Iterator_T<
TYPE, FUNCTOR, ACE_LOCK > 
ITERATOR
 Type of Iterator.


Public Member Functions

 ACE_Timer_Queue_T (FUNCTOR *upcall_functor=0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *freelist=0)
virtual ~ACE_Timer_Queue_T (void)
virtual int is_empty (void) const=0
 True if queue is empty, else false.

virtual const ACE_Time_Valueearliest_time (void) const=0
virtual long schedule (const TYPE &type, const void *act, const ACE_Time_Value &future_time, const ACE_Time_Value &interval=ACE_Time_Value::zero)
virtual int reset_interval (long timer_id, const ACE_Time_Value &interval)=0
virtual int cancel (const TYPE &type, int dont_call_handle_close=1)=0
virtual int cancel (long timer_id, const void **act=0, int dont_call_handle_close=1)=0
virtual int expire (const ACE_Time_Value &current_time)
virtual int dispatch_info (const ACE_Time_Value &current_time, ACE_Timer_Node_Dispatch_Info_T< TYPE > &info)
int expire (void)
ACE_Time_Value gettimeofday (void)
void gettimeofday (ACE_Time_Value(*gettimeofday)(void))
virtual ACE_Time_Valuecalculate_timeout (ACE_Time_Value *max)
virtual ACE_Time_Valuecalculate_timeout (ACE_Time_Value *max, ACE_Time_Value *the_timeout)
void timer_skew (const ACE_Time_Value &skew)
 Set the timer skew for the Timer_Queue.

const ACE_Time_Valuetimer_skew (void) const
 Get the timer skew for the Timer_Queue.

ACE_LOCK & mutex (void)
 Synchronization variable used by the queue.

FUNCTOR & upcall_functor (void)
 Accessor to the upcall functor.

virtual ITERATORiter (void)=0
 Returns a pointer to this ACE_Timer_Queue's iterator.

virtual ACE_Timer_Node_T<
TYPE > * 
remove_first (void)=0
 Removes the earliest node from the queue and returns it.

virtual void dump (void) const
 Dump the state of a object.

virtual ACE_Timer_Node_T<
TYPE > * 
get_first (void)=0
 Reads the earliest node from the queue and returns it.

virtual void return_node (ACE_Timer_Node_T< TYPE > *)
void preinvoke (ACE_Timer_Node_Dispatch_Info_T< TYPE > &info, const ACE_Time_Value &cur_time, const void *&upcall_act)
 This method will call the preinvoke() on .

void upcall (ACE_Timer_Node_Dispatch_Info_T< TYPE > &info, const ACE_Time_Value &cur_time)
 This method will call the timeout() on .

void postinvoke (ACE_Timer_Node_Dispatch_Info_T< TYPE > &info, const ACE_Time_Value &cur_time, const void *upcall_act)
 This method will call the postinvoke() on .


Protected Member Functions

virtual long schedule_i (const TYPE &type, const void *act, const ACE_Time_Value &future_time, const ACE_Time_Value &interval)=0
 Schedule a timer.

virtual void reschedule (ACE_Timer_Node_T< TYPE > *)=0
 Reschedule an "interval" .

virtual ACE_Timer_Node_T<
TYPE > * 
alloc_node (void)
 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 &current_time, ACE_Timer_Node_Dispatch_Info_T< TYPE > &info)
 Non-locking version of dispatch_info ().


Protected Attributes

ACE_LOCK mutex_
ACE_Free_List< ACE_Timer_Node_T<
TYPE > > * 
free_list_
 Class that implements a free list.

ACE_Time_Value(* gettimeofday_ )(void)
 Pointer to function that returns the current time of day.

FUNCTOR * upcall_functor_
 Upcall functor.

int delete_upcall_functor_
 To delete or not to delete is the question?

int delete_free_list_
 Flag to delete only if the class created the .


Private Member Functions

 ACE_Timer_Queue_T (const ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > &)
void operator= (const ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > &)

Private Attributes

ACE_Time_Value timeout_
 Returned by .

ACE_Time_Value timer_skew_
 Adjusts for timer skew in various clocks.


Detailed Description

template<class TYPE, class FUNCTOR, class ACE_LOCK>
class ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >

Provides an interface to timers.

This is an abstract base class that provides hook for implementing specialized policies such as ACE_Timer_List and ACE_Timer_Heap.

Definition at line 207 of file Timer_Queue_T.h.


Member Typedef Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK>
typedef ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::ITERATOR
 

Type of Iterator.

Definition at line 211 of file Timer_Queue_T.h.


Constructor & Destructor Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Queue_T FUNCTOR *  upcall_functor = 0,
ACE_Free_List< ACE_Timer_Node_T< TYPE > > *  freelist = 0
 

Default constructor. is the instance of the FUNCTOR to be used by the queue. If is 0, Timer Queue will create a default FUNCTOR. the freelist of timer nodes. If 0, then a default freelist will be created.

Definition at line 163 of file Timer_Queue_T.cpp.

References ACE_NEW, ACE_TIMER_SKEW, ACE_TRACE, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor_.

00165   : gettimeofday_ (ACE_OS::gettimeofday),
00166     delete_upcall_functor_ (upcall_functor == 0),
00167     delete_free_list_ (freelist == 0),
00168     timer_skew_ (0, ACE_TIMER_SKEW)
00169 {
00170   ACE_TRACE ("ACE_Timer_Queue_T::ACE_Timer_Queue_T");
00171 
00172   if (!freelist)
00173     ACE_NEW (free_list_,
00174              (ACE_Locked_Free_List<ACE_Timer_Node_T<TYPE>,ACE_Null_Mutex>));
00175   else
00176     free_list_ = freelist;
00177 
00178   if (!upcall_functor)
00179     ACE_NEW (upcall_functor_,
00180              FUNCTOR);
00181   else
00182     upcall_functor_ = upcall_functor;
00183 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Queue_T void   )  [virtual]
 

Destructor - make virtual for proper destruction of inherited classes.

Definition at line 186 of file Timer_Queue_T.cpp.

References ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::delete_free_list_, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::delete_upcall_functor_, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor_.

00187 {
00188   ACE_TRACE ("ACE_Timer_Queue_T::~ACE_Timer_Queue_T");
00189 
00190   // Cleanup the functor and free_list on the way out
00191   if (this->delete_upcall_functor_)
00192     delete this->upcall_functor_;
00193 
00194   if (this->delete_free_list_)
00195     delete this->free_list_;
00196 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Queue_T const ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > &   )  [private]
 


Member Function Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Timer_Node_T< TYPE > * ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::alloc_node void   )  [protected, virtual]
 

Factory method that allocates a new node.

Reimplemented in ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >.

Definition at line 199 of file Timer_Queue_T.cpp.

References ACE_Free_List< ACE_Timer_Node_T< TYPE > >::remove().

Referenced by ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::schedule_i(), and ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >::schedule_i().

00200 {
00201   return this->free_list_->remove ();
00202 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Time_Value * ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout ACE_Time_Value max,
ACE_Time_Value the_timeout
[virtual]
 

Determine the next event to timeout. Returns if there are no pending timers or if all pending timers are longer than max. should be a pointer to storage for the timeout value, and this value is also returned. This method does not acquire a lock internally since it doesn't modify internal state. If you need to call this method when the queue is being modified concurrently, however, you should make sure to acquire the <mutex()> externally before making the call.

Definition at line 108 of file Timer_Queue_T.cpp.

References ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::earliest_time(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty().

00110 {
00111   ACE_TRACE ("ACE_Timer_Queue_T::calculate_timeout");
00112 
00113   if (the_timeout == 0)
00114     return 0;
00115 
00116   if (this->is_empty ())
00117     {
00118       // Nothing on the Timer_Queue, so use whatever the caller gave us.
00119       if (max_wait_time)
00120         *the_timeout = *max_wait_time;
00121       else
00122         return 0;
00123     }
00124   else
00125     {
00126       ACE_Time_Value cur_time = this->gettimeofday ();
00127 
00128       if (this->earliest_time () > cur_time)
00129         {
00130           // The earliest item on the Timer_Queue is still in the
00131           // future.  Therefore, use the smaller of (1) caller's wait
00132           // time or (2) the delta time between now and the earliest
00133           // time on the Timer_Queue.
00134 
00135           *the_timeout = this->earliest_time () - cur_time;
00136           if (!(max_wait_time == 0 || *max_wait_time > *the_timeout))
00137             *the_timeout = *max_wait_time;
00138         }
00139       else
00140         {
00141           // The earliest item on the Timer_Queue is now in the past.
00142           // Therefore, we've got to "poll" the Reactor, i.e., it must
00143           // just check the descriptors and then dispatch timers, etc.
00144           *the_timeout = ACE_Time_Value::zero;
00145         }
00146     }
00147   return the_timeout;
00148 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Time_Value * ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout ACE_Time_Value max  )  [virtual]
 

Determine the next event to timeout. Returns if there are no pending timers or if all pending timers are longer than max. This method acquires a lock internally since it modifies internal state.

Definition at line 71 of file Timer_Queue_T.cpp.

References ACE_GUARD_RETURN, ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::earliest_time(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty().

Referenced by ACE_WFMO_Reactor::calculate_timeout(), ACE_XtReactor::reset_timeout(), ACE_TkReactor::reset_timeout(), ACE_QtReactor::reset_timeout(), ACE_FlReactor::reset_timeout(), ACE_XtReactor::wait_for_multiple_events(), ACE_TkReactor::wait_for_multiple_events(), ACE_QtReactor::wait_for_multiple_events(), ACE_FlReactor::wait_for_multiple_events(), and ACE_Dev_Poll_Reactor::work_pending_i().

00072 {
00073   ACE_TRACE ("ACE_Timer_Queue_T::calculate_timeout");
00074   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, max_wait_time));
00075 
00076   if (this->is_empty ())
00077     // Nothing on the Timer_Queue, so use whatever the caller gave us.
00078     return max_wait_time;
00079   else
00080     {
00081       ACE_Time_Value cur_time = this->gettimeofday ();
00082 
00083       if (this->earliest_time () > cur_time)
00084         {
00085           // The earliest item on the Timer_Queue is still in the
00086           // future.  Therefore, use the smaller of (1) caller's wait
00087           // time or (2) the delta time between now and the earliest
00088           // time on the Timer_Queue.
00089 
00090           this->timeout_ = this->earliest_time () - cur_time;
00091           if (max_wait_time == 0 || *max_wait_time > timeout_)
00092             return &this->timeout_;
00093           else
00094             return max_wait_time;
00095         }
00096       else
00097         {
00098           // The earliest item on the Timer_Queue is now in the past.
00099           // Therefore, we've got to "poll" the Reactor, i.e., it must
00100           // just check the descriptors and then dispatch timers, etc.
00101           this->timeout_ = ACE_Time_Value::zero;
00102           return &this->timeout_;
00103         }
00104     }
00105 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::cancel long  timer_id,
const void **  act = 0,
int  dont_call_handle_close = 1
[pure virtual]
 

Cancel the single timer that matches the value (which was returned from the 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 is 0 then the will be invoked, which typically calls the hook. Returns 1 if cancellation succeeded and 0 if the wasn't found.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::cancel const TYPE &  type,
int  dont_call_handle_close = 1
[pure virtual]
 

Cancel all timer associated with . If is 0 then the will be invoked, which typically invokes the hook. Returns number of timers cancelled.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_WFMO_Reactor::cancel_timer(), ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer(), and ACE_Dev_Poll_Reactor::cancel_timer().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info const ACE_Time_Value current_time,
ACE_Timer_Node_Dispatch_Info_T< TYPE > &  info
[virtual]
 

Get the dispatch information for a timer whose value is <= . This does not account for . Returns 1 if there is a node whose value <= else returns a 0.

Definition at line 157 of file Timer_Queue_T.inl.

References ACE_GUARD_RETURN, ACE_TRACE, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i().

Referenced by ACE_Dev_Poll_Reactor::dispatch_timer_handler(), and ACE_TP_Reactor::handle_timer_events().

00159 {
00160   ACE_TRACE ("ACE_Timer_Queue_T::dispatch_info");
00161   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0));
00162 
00163   return this->dispatch_info_i (cur_time, info);
00164 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i const ACE_Time_Value current_time,
ACE_Timer_Node_Dispatch_Info_T< TYPE > &  info
[protected, virtual]
 

Non-locking version of dispatch_info ().

Reimplemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >.

Definition at line 283 of file Timer_Queue_T.cpp.

References ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::earliest_time(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::free_node(), ACE_Timer_Node_T< TYPE >::get_dispatch_info(), ACE_Timer_Node_T< TYPE >::get_interval(), ACE_Timer_Node_T< TYPE >::get_timer_value(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::remove_first(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::reschedule(), and ACE_Timer_Node_T< TYPE >::set_timer_value().

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info(), ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::dispatch_info_i(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire().

00285 {
00286   ACE_TRACE ("ACE_Timer_Queue_T::dispatch_info_i");
00287 
00288   if (this->is_empty ())
00289     return 0;
00290 
00291   ACE_Timer_Node_T<TYPE> *expired = 0;
00292 
00293   if (this->earliest_time () <= cur_time)
00294     {
00295       expired = this->remove_first ();
00296 
00297       // Get the dispatch info
00298       expired->get_dispatch_info (info);
00299 
00300       // Check if this is an interval timer.
00301       if (expired->get_interval () > ACE_Time_Value::zero)
00302         {
00303           // Make sure that we skip past values that have already
00304           // "expired".
00305           do
00306             expired->set_timer_value (expired->get_timer_value () +
00307                                       expired->get_interval ());
00308           while (expired->get_timer_value () <= cur_time);
00309 
00310           // Since this is an interval timer, we need to reschedule
00311           // it.
00312           this->reschedule (expired);
00313         }
00314       else
00315         {
00316           // Call the factory method to free up the node.
00317           this->free_node (expired);
00318         }
00319 
00320       return 1;
00321     }
00322 
00323   return 0;
00324 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dump void   )  const [virtual]
 

Dump the state of a object.

Reimplemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Definition at line 151 of file Timer_Queue_T.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_TRACE, ACE_Time_Value::dump(), LM_DEBUG, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew_.

Referenced by ACE_WFMO_Reactor_Notify::dump(), ACE_WFMO_Reactor::dump(), and ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dump().

00152 {
00153 #if defined (ACE_HAS_DUMP)
00154   ACE_TRACE ("ACE_Timer_Queue_T::dump");
00155   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00156   this->timeout_.dump ();
00157   this->timer_skew_.dump ();
00158   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00159 #endif /* ACE_HAS_DUMP */
00160 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual const ACE_Time_Value& ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::earliest_time void   )  const [pure virtual]
 

Returns the time of the earlier node in the Timer_Queue. Must be called on a non-empty queue.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire void   ) 
 

Run the for all timers whose values are <= <ACE_OS::gettimeofday>. Also accounts for .

Depending on the resolution of the underlying OS the system calls like select()/poll() might return at time different than that is specified in the timeout. Suppose the OS guarantees a resolution of t ms. The timeline will look like

A B | | V V |-------------|-------------|-------------|-------------| t t t t t

If you specify a timeout value of A, then the timeout will not occur at A but at the next interval of the timer, which is later than that is expected. Similarly, if your timeout value is equal to B, then the timeout will occur at interval after B. Now depending upon the resolution of your timeouts and the accuracy of the timeouts needed for your application, you should set the value of . In the above case, if you want the timeout A to fire no later than A, then you should specify your to be A t.

The timeout value should be specified via the macro ACE_TIMER_SKEW in your config.h file. The default value is zero.

Things get interesting if the t before the timeout value B is zero i.e your timeout is less than the interval. In that case, you are almost sure of not getting the desired timeout behaviour. Maybe you should look for a better OS :-)

Returns the number of timers canceled.

Reimplemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Definition at line 148 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew_.

Referenced by ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), and ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire().

00149 {
00150   if (!this->is_empty ())
00151     return this->expire (this->gettimeofday () + timer_skew_);
00152   else
00153     return 0;
00154 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire const ACE_Time_Value current_time  )  [virtual]
 

Run the for all timers whose values are <= . This does not account for . Returns the number of timers canceled.

Reimplemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Definition at line 247 of file Timer_Queue_T.cpp.

References ACE_GUARD_RETURN, ACE_TRACE, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::postinvoke(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::preinvoke(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall().

Referenced by ACE_WFMO_Reactor::expire_timers().

00248 {
00249   ACE_TRACE ("ACE_Timer_Queue_T::expire");
00250   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
00251 
00252   // Keep looping while there are timers remaining and the earliest
00253   // timer is <= the <cur_time> passed in to the method.
00254 
00255   if (this->is_empty ())
00256     return 0;
00257 
00258   int number_of_timers_expired = 0;
00259   int result = 0;
00260 
00261   ACE_Timer_Node_Dispatch_Info_T<TYPE> info;
00262 
00263   while ((result = this->dispatch_info_i (cur_time,
00264                                           info)) != 0)
00265     {
00266       const void *upcall_act = 0;
00267 
00268       this->preinvoke (info, cur_time, upcall_act);
00269 
00270       this->upcall (info, cur_time);
00271 
00272       this->postinvoke (info, cur_time, upcall_act);
00273 
00274       ++number_of_timers_expired;
00275 
00276     }
00277 
00278   ACE_UNUSED_ARG (result);
00279   return number_of_timers_expired;
00280 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::free_node ACE_Timer_Node_T< TYPE > *   )  [protected, virtual]
 

Factory method that frees a previously allocated node.

Reimplemented in ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >.

Definition at line 205 of file Timer_Queue_T.cpp.

References ACE_Free_List< ACE_Timer_Node_T< TYPE > >::add().

Referenced by ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::cancel_i(), ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >::cancel_i(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i(), ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::return_node(), ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_List_T(), and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Wheel_T().

00206 {
00207   this->free_list_->add (node);
00208 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual ACE_Timer_Node_T<TYPE>* ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::get_first void   )  [pure virtual]
 

Reads the earliest node from the queue and returns it.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday ACE_Time_Value(*  gettimeofday)(void)  ) 
 

Allows applications to control how the timer queue gets the time of day.

Definition at line 211 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday_.

00212 {
00213   this->gettimeofday_ = gettimeofday;
00214 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE ACE_Time_Value ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday void   ) 
 

Returns the current time of day. This method allows different implementations of the timer queue to use special high resolution timers.

Definition at line 204 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday_.

Referenced by ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::ACE_Timer_Hash_T(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout(), ACE_WFMO_Reactor_Notify::notify(), ACE_WFMO_Reactor::schedule_timer(), and ACE_Dev_Poll_Reactor::schedule_timer().

00205 {
00206   // Invoke gettimeofday via pointer to function.
00207   return this->gettimeofday_ ();
00208 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::is_empty void   )  const [pure virtual]
 

True if queue is empty, else false.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::calculate_timeout(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i(), ACE_Dev_Poll_Reactor::dispatch_timer_handler(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), and ACE_TP_Reactor::handle_timer_events().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual ITERATOR& ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::iter void   )  [pure virtual]
 

Returns a pointer to this ACE_Timer_Queue's iterator.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_LOCK & ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::mutex void   ) 
 

Synchronization variable used by the queue.

Definition at line 211 of file Timer_Queue_T.cpp.

00212 {
00213   return this->mutex_;
00214 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::operator= const ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK > &   )  [private]
 

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::postinvoke ACE_Timer_Node_Dispatch_Info_T< TYPE > &  info,
const ACE_Time_Value cur_time,
const void *  upcall_act
 

This method will call the postinvoke() on .

Definition at line 191 of file Timer_Queue_T.inl.

References ACE_Timer_Node_Dispatch_Info_T< TYPE >::act_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::recurring_timer_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::type_, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor().

Referenced by ACE_Dev_Poll_Reactor::dispatch_timer_handler(), ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire(), and ACE_TP_Reactor::handle_timer_events().

00194 {
00195   this->upcall_functor ().postinvoke (*this,
00196                                       info.type_,
00197                                       info.act_,
00198                                       info.recurring_timer_,
00199                                       cur_time,
00200                                       upcall_act);
00201 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::preinvoke ACE_Timer_Node_Dispatch_Info_T< TYPE > &  info,
const ACE_Time_Value cur_time,
const void *&  upcall_act
 

This method will call the preinvoke() on .

Definition at line 178 of file Timer_Queue_T.inl.

References ACE_Timer_Node_Dispatch_Info_T< TYPE >::act_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::recurring_timer_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::type_, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor().

Referenced by ACE_Dev_Poll_Reactor::dispatch_timer_handler(), ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire(), and ACE_TP_Reactor::handle_timer_events().

00181 {
00182   this->upcall_functor ().preinvoke (*this,
00183                                      info.type_,
00184                                      info.act_,
00185                                      info.recurring_timer_,
00186                                      cur_time,
00187                                      upcall_act);
00188 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual ACE_Timer_Node_T<TYPE>* ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::remove_first void   )  [pure virtual]
 

Removes the earliest node from the queue and returns it.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::reschedule ACE_Timer_Node_T< TYPE > *   )  [protected, pure virtual]
 

Reschedule an "interval" .

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dispatch_info_i().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::reset_interval long  timer_id,
const ACE_Time_Value interval
[pure virtual]
 

Resets the interval of the timer represented by to , which is specified in relative time to the current . If is equal to <ACE_Time_Value::zero>, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Dev_Poll_Reactor::reset_timer_interval().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::return_node ACE_Timer_Node_T< TYPE > *   )  [virtual]
 

Method used to return a timer node to the queue's ownership after it is returned by a method like .

Definition at line 327 of file Timer_Queue_T.cpp.

References ACE_GUARD, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::free_node().

00328 {
00329   ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));
00330   this->free_node (node);
00331 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
long ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule const TYPE &  type,
const void *  act,
const ACE_Time_Value future_time,
const ACE_Time_Value interval = ACE_Time_Value::zero
[virtual]
 

Schedule that will expire at , which is specified in absolute time. If it expires then is passed in as the value to the . If is != to <ACE_Time_Value::zero> then it is used to reschedule the automatically, using relative time to the current . This method returns a that uniquely identifies the the entry in an internal list. This can be used to cancel the timer before it expires. The cancellation ensures that 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 ).

Definition at line 217 of file Timer_Queue_T.cpp.

References ACE_GUARD_RETURN, ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule_i(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor().

Referenced by ACE_WFMO_Reactor::schedule_timer(), and ACE_Dev_Poll_Reactor::schedule_timer().

00221 {
00222   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
00223 
00224   // Schedule the timer.
00225   long const result =
00226     this->schedule_i (type,
00227                       act,
00228                       future_time,
00229                       interval);
00230 
00231   // Return on failure.
00232   if (result == -1)
00233     return result;
00234 
00235   // Inform upcall functor of successful registration.
00236   this->upcall_functor ().registration (*this,
00237                                         type,
00238                                         act);
00239 
00240   // Return result;
00241   return result;
00242 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
virtual long ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule_i const TYPE &  type,
const void *  act,
const ACE_Time_Value future_time,
const ACE_Time_Value interval
[protected, pure virtual]
 

Schedule a timer.

Implemented in ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >, ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >, ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >, and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE const ACE_Time_Value & ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew void   )  const
 

Get the timer skew for the Timer_Queue.

Definition at line 142 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew_.

00143 {
00144   return timer_skew_;
00145 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew const ACE_Time_Value skew  ) 
 

Set the timer skew for the Timer_Queue.

Definition at line 136 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew_.

Referenced by ACE_Dev_Poll_Reactor::dispatch_timer_handler(), and ACE_TP_Reactor::handle_timer_events().

00137 {
00138   timer_skew_ = skew;
00139 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE void ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall ACE_Timer_Node_Dispatch_Info_T< TYPE > &  info,
const ACE_Time_Value cur_time
 

This method will call the timeout() on .

Definition at line 167 of file Timer_Queue_T.inl.

References ACE_Timer_Node_Dispatch_Info_T< TYPE >::act_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::recurring_timer_, ACE_Timer_Node_Dispatch_Info_T< TYPE >::type_, and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor().

Referenced by ACE_Dev_Poll_Reactor::dispatch_timer_handler(), ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire(), and ACE_TP_Reactor::handle_timer_events().

00169 {
00170   this->upcall_functor ().timeout (*this,
00171                                    info.type_,
00172                                    info.act_,
00173                                    info.recurring_timer_,
00174                                    cur_time);
00175 }

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_INLINE FUNCTOR & ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor void   ) 
 

Accessor to the upcall functor.

Definition at line 217 of file Timer_Queue_T.inl.

References ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor_.

Referenced by ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::cancel(), ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >::cancel(), ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::cancel(), ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::cancel(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::postinvoke(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::preinvoke(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::schedule(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall(), ACE_Timer_Heap_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Heap_T(), ACE_Timer_List_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_List_T(), and ACE_Timer_Wheel_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Wheel_T().

00218 {
00219   return *this->upcall_functor_;
00220 }


Member Data Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK>
int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::delete_free_list_ [protected]
 

Flag to delete only if the class created the .

Definition at line 451 of file Timer_Queue_T.h.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Queue_T().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
int ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::delete_upcall_functor_ [protected]
 

To delete or not to delete is the question?

Definition at line 448 of file Timer_Queue_T.h.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Queue_T().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Free_List<ACE_Timer_Node_T<TYPE> >* ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::free_list_ [protected]
 

Class that implements a free list.

Definition at line 439 of file Timer_Queue_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Time_Value(* ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday_)(void) [protected]
 

Pointer to function that returns the current time of day.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::gettimeofday().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_LOCK ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::mutex_ [protected]
 

Synchronization variable for ACE_Timer_Queue.

Note:
The right name would be lock_, but HP/C++ will choke on that!

Definition at line 436 of file Timer_Queue_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Time_Value ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timeout_ [private]
 

Returned by .

Definition at line 456 of file Timer_Queue_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK>
ACE_Time_Value ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew_ [private]
 

Adjusts for timer skew in various clocks.

Definition at line 459 of file Timer_Queue_T.h.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::dump(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::expire(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::timer_skew().

template<class TYPE, class FUNCTOR, class ACE_LOCK>
FUNCTOR* ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor_ [protected]
 

Upcall functor.

Definition at line 445 of file Timer_Queue_T.h.

Referenced by ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::ACE_Timer_Queue_T(), ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::upcall_functor(), and ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >::~ACE_Timer_Queue_T().


The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:31:25 2006 for ACE by doxygen 1.3.6