---

ACE_Timer_Hash_T Class Template Reference

Provides a hash table of <BUCKET>s as an implementation for a timer queue. More...

#include <Timer_Hash_T.h>

Inheritance diagram for ACE_Timer_Hash_T:

[legend]Collaboration diagram for ACE_Timer_Hash_T:

[legend]List of all members.

Public Types
typedef ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >	HASH_ITERATOR
	Type of iterator. More...
typedef ACE_Timer_Queue_T< TYPE, FUNCTOR, ACE_LOCK >	INHERITED
	Type inherited from. More...
Public Methods
	ACE_Timer_Hash_T (size_t table_size, FUNCTOR *upcall_functor=0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *freelist=0)
	ACE_Timer_Hash_T (FUNCTOR *upcall_functor=0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *freelist=0)
virtual	~ACE_Timer_Hash_T (void)
	Destructor. More...
virtual int	is_empty (void) const
	True if queue is empty, else false. More...
virtual const ACE_Time_Value &	earliest_time (void) const
	Returns the time of the earlier node in the <ACE_Timer_Hash>. Must be called on a non-empty queue. More...
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)
virtual int	cancel (const TYPE &type, int dont_call_handle_close=1)
virtual int	cancel (long timer_id, const void **act=0, int dont_call_handle_close=1)
virtual int	expire (void)
virtual int	expire (const ACE_Time_Value &current_time)
virtual ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > &	iter (void)
	Returns a pointer to this <ACE_Timer_Queue>'s iterator. More...
virtual ACE_Timer_Node_T< TYPE > *	remove_first (void)
	Removes the earliest node from the queue and returns it. More...
virtual void	dump (void) const
	Dump the state of an object. More...
virtual ACE_Timer_Node_T< TYPE > *	get_first (void)
	Reads the earliest node from the queue and returns it. More...
Private Methods
virtual void	reschedule (ACE_Timer_Node_T< TYPE > *)
	Reschedule an "interval" <ACE_Timer_Node>. More...
void	find_new_earliest (void)
	Finds the earliest node. More...
	ACE_Timer_Hash_T (const ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > &)
void	operator= (const ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > &)
Private Attributes
size_t	size_
	Keeps track of the size of the queue. More...
BUCKET **	table_
	Table of BUCKETS. More...
size_t	table_size_
	Keeps track of the size of table_. More...
ACE_Timer_Hash_Upcall< TYPE, FUNCTOR, ACE_LOCK >	table_functor_
	Functor used for the table's timer queues. More...
size_t	earliest_position_
	Index to the position with the earliest entry. More...
HASH_ITERATOR *	iterator_
	Iterator used to expire timers. More...
Friends
class	ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >
	Iterator is a friend. More...

---

Detailed Description

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET>
class ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >

Provides a hash table of <BUCKET>s as an implementation for a timer queue.

This implementation uses a hash table of BUCKETs. The hash is based on the time_value of the event. Unlike other Timer Queues, ACE_Timer_Hash does not expire events in order.

Definition at line 128 of file Timer_Hash_T.h.

---

Member Typedef Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> typedef ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET> ACE_Timer_Hash_T::HASH_ITERATOR

Type of iterator. Definition at line 133 of file Timer_Hash_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> ACE_Timer_Hash_T::INHERITED

Type inherited from. Definition at line 139 of file Timer_Hash_T.h.

---

Constructor & Destructor Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::ACE_Timer_Hash_T (  size_t    table_size, FUNCTOR *    upcall_functor = 0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *    freelist = 0 )

Default constructor. <table_size> determines the size of the hash table. <upcall_functor> is the instance of the FUNCTOR to be used by the buckets. If <upcall_functor> is 0, a default FUNCTOR will be created. Definition at line 200 of file Timer_Hash_T.cpp. References ACE_NEW, ACE_TRACE, ACE_OS::gettimeofday, ACE_Timer_Queue_T::gettimeofday, iterator_, and table_. : ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> (upcall_functor, freelist), size_ (0), table_size_ (table_size), table_functor_ (this), earliest_position_ (0) #if defined (ACE_WIN64) , pointer_base_ (0) #endif /* ACE_WIN64 */ { ACE_TRACE ("ACE_Timer_Hash_T::ACE_Timer_Hash_T"); ACE_NEW (table_, BUCKET *[table_size]); this->gettimeofday (ACE_OS::gettimeofday); for (size_t i = 0; i < table_size; i++) { ACE_NEW (this->table_[i], BUCKET (&this->table_functor_, this->free_list_)); this->table_[i]->gettimeofday (ACE_OS::gettimeofday); } ACE_NEW (iterator_, HASH_ITERATOR (*this)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::ACE_Timer_Hash_T (  FUNCTOR *    upcall_functor = 0, ACE_Free_List< ACE_Timer_Node_T< TYPE > > *    freelist = 0 )

Default constructor. <upcall_functor> is the instance of the FUNCTOR to be used by the queue. If <upcall_functor> is 0, Timer Hash will create a default FUNCTOR. <freelist> the freelist of timer nodes. If 0, then a default freelist will be created. The default size will be ACE_DEFAULT_TIMERS and there will be no preallocation. Definition at line 235 of file Timer_Hash_T.cpp. References ACE_DEFAULT_TIMER_HASH_TABLE_SIZE, ACE_NEW, ACE_TRACE, ACE_OS::gettimeofday, ACE_Timer_Queue_T::gettimeofday, iterator_, table_, and table_size_. : ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> (upcall_functor, freelist), size_ (0), table_size_ (ACE_DEFAULT_TIMER_HASH_TABLE_SIZE), table_functor_ (this), earliest_position_ (0) #if defined (ACE_WIN64) , pointer_base_ (0) #endif /* ACE_WIN64 */ { ACE_TRACE ("ACE_Timer_Hash_T::ACE_Timer_Hash_T"); ACE_NEW (table_, BUCKET *[ACE_DEFAULT_TIMER_HASH_TABLE_SIZE]); this->gettimeofday (ACE_OS::gettimeofday); for (size_t i = 0; i < this->table_size_; i++) { ACE_NEW (this->table_[i], BUCKET (&this->table_functor_, this->free_list_)); this->table_[i]->gettimeofday (ACE_OS::gettimeofday); } ACE_NEW (iterator_, HASH_ITERATOR (*this)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::~ACE_Timer_Hash_T (  void    )  [virtual]

Destructor. Definition at line 271 of file Timer_Hash_T.cpp. References ACE_GUARD, ACE_MT, ACE_TRACE, iterator_, table_, and table_size_. { ACE_TRACE ("ACE_Timer_Hash_T::~ACE_Timer_Hash_T"); ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); delete iterator_; for (size_t i = 0; i < this->table_size_; i++) delete this->table_[i]; delete [] this->table_; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::ACE_Timer_Hash_T (  const ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > &    )  [private]

---

Member Function Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::cancel (  long    timer_id, const void **    act = 0, int    dont_call_handle_close = 1 )  [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_Timer_Queue_T. Definition at line 431 of file Timer_Hash_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, Hash_Token::act_, earliest_position_, find_new_earliest, Hash_Token::orig_id_, Hash_Token::pos_, size_, and table_. { ACE_TRACE ("ACE_Timer_Hash_T::cancel"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Make sure we are getting a valid <timer_id>, not an error // returned by <schedule>. if (timer_id == -1) return 0; #if defined (ACE_WIN64) unsigned long timer_offset = ACE_static_cast (unsigned long, timer_id); Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, (this->pointer_base_ + timer_offset)); #else Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, timer_id); #endif /* ACE_WIN64 */ int result = this->table_[h->pos_]->cancel (h->orig_id_, act, dont_call); if (h->pos_ == this->earliest_position_) this->find_new_earliest (); if (act != 0) *act = h->act_; delete h; --this->size_; return result; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::cancel (  const TYPE &    type, int    dont_call_handle_close = 1 )  [virtual]

Cancel all timer associated with <type>. If <dont_call> is 0 then the <functor> will be invoked. Returns number of timers cancelled. Implements ACE_Timer_Queue_T. Definition at line 472 of file Timer_Hash_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_TRACE, find_new_earliest, iter, Hash_Token::pos_, size_, table_, table_size_, and ACE_Timer_Queue_T::upcall_functor. { ACE_TRACE ("ACE_Timer_Hash_T::cancel"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); size_t i; // loop variable. Hash_Token **timer_ids; ACE_NEW_RETURN (timer_ids, Hash_Token *[this->size_], -1); size_t pos = 0; for (i = 0; i < this->table_size_; i++) { ACE_Timer_Queue_Iterator_T<TYPE, ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>, ACE_Null_Mutex> &iter = this->table_[i]->iter (); for (iter.first (); !iter.isdone (); iter.next ()) if (iter.item ()->get_type () == type) timer_ids[pos++] = ACE_reinterpret_cast (Hash_Token *, ACE_const_cast (void *, iter.item ()->get_act ())); } if (pos > this->size_) return -1; for (i = 0; i < pos; i++) { this->table_[timer_ids[i]->pos_]->cancel (timer_ids[i]->orig_id_, 0, 1); delete timer_ids[i]; --this->size_; } delete [] timer_ids; if (dont_call == 0) this->upcall_functor ().cancellation (*this, type); this->find_new_earliest (); return ACE_static_cast (int, pos); }

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

Dump the state of an object. Reimplemented from ACE_Timer_Queue_T. Definition at line 305 of file Timer_Hash_T.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, LM_DEBUG, table_, and table_size_. { ACE_TRACE ("ACE_Timer_Hash_T::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntable_size_ = %d"), this->table_size_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nearliest_position_ = %d"), this->earliest_position_)); for (size_t i = 0; i < this->table_size_; i++) if (!this->table_[i]->is_empty ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nBucket %d contains nodes"), i)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n"))); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> const ACE_Time_Value & ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::earliest_time (  void    )  const [virtual]

Returns the time of the earlier node in the <ACE_Timer_Hash>. Must be called on a non-empty queue. Implements ACE_Timer_Queue_T. Definition at line 298 of file Timer_Hash_T.cpp. References ACE_TRACE, earliest_position_, and table_. Referenced by find_new_earliest. { ACE_TRACE ("ACE_Timer_Hash_T::earliest_time"); return this->table_[this->earliest_position_]->earliest_time (); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire (  const ACE_Time_Value &    current_time )  [virtual]

Run the <functor> for all timers whose values are <= <cur_time>. This does not account for <timer_skew>. Returns the number of timers canceled. Reimplemented from ACE_Timer_Queue_T. Definition at line 584 of file Timer_Hash_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, Hash_Token::act_, ACE_Timer_Node_T::get_act, ACE_Timer_Node_T::get_interval, ACE_Timer_Node_T::get_timer_id, ACE_Timer_Node_T::get_timer_value, ACE_Timer_Node_T::get_type, reschedule, ACE_Timer_Node_T::set_timer_value, size_, table_, table_size_, ACE_Timer_Queue_T::upcall, and ACE_Time_Value::zero. { ACE_TRACE ("ACE_Timer_Hash_T::expire"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); int number_of_timers_expired = 0; ACE_Timer_Node_T<TYPE> *expired; // Go through the table and expire anything that can be expired for (size_t i = 0; i < this->table_size_; i++) { while (!this->table_[i]->is_empty () && this->table_[i]->earliest_time () <= cur_time) { expired = this->table_[i]->get_first (); TYPE type = expired->get_type (); const void *act = expired->get_act (); int reclaim = 1; // Check if this is an interval timer. if (expired->get_interval () > ACE_Time_Value::zero) { // Make sure that we skip past values that have already // "expired". do expired->set_timer_value (expired->get_timer_value () + expired->get_interval ()); while (expired->get_timer_value () <= cur_time); // Since this is an interval timer, we need to // reschedule it. this->reschedule (expired); reclaim = 0; } // Now remove the timer from the original table... if // it's a simple, non-recurring timer, it's got to be // removed anyway. If it was rescheduled, it's been // scheduled into the correct table (regardless of whether // it's the same one or not) already. this->table_[i]->cancel (expired->get_timer_id ()); Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, ACE_const_cast (void *, act)); // Call the functor. this->upcall (type, h->act_, cur_time); if (reclaim) { --this->size_; delete h; } number_of_timers_expired++; } } return number_of_timers_expired; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::expire (  void    )  [virtual]

Run the <functor> for all timers whose values are <= <ACE_OS::gettimeofday>. Also accounts for <timer_skew>. Returns the number of timers canceled. Reimplemented from ACE_Timer_Queue_T. Definition at line 576 of file Timer_Hash_T.cpp. References ACE_Timer_Queue_T::expire. { return ACE_Timer_Queue_T<TYPE,FUNCTOR,ACE_LOCK>::expire(); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> void ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::find_new_earliest (  void    )  [private]

Finds the earliest node. Definition at line 550 of file Timer_Hash_T.cpp. References earliest_position_, earliest_time, table_, table_size_, and ACE_Time_Value::zero. Referenced by cancel, and remove_first. { for (size_t i = 0; i < this->table_size_; i++) if (!this->table_[i]->is_empty ()) if (this->table_[this->earliest_position_]->is_empty () || this->earliest_time () == ACE_Time_Value::zero || this->table_[i]->earliest_time () <= this->earliest_time ()) this->earliest_position_ = i; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Node_T< TYPE > * ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::get_first (  void    )  [virtual]

Reads the earliest node from the queue and returns it. Implements ACE_Timer_Queue_T. Definition at line 563 of file Timer_Hash_T.cpp. References ACE_TRACE, earliest_position_, is_empty, and table_. { ACE_TRACE ("ACE_Timer_Hash_T::get_first"); if (this->is_empty ()) return 0; return this->table_[this->earliest_position_]->get_first (); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::is_empty (  void    )  const [virtual]

True if queue is empty, else false. Implements ACE_Timer_Queue_T. Definition at line 289 of file Timer_Hash_T.cpp. References ACE_TRACE, earliest_position_, and table_. Referenced by get_first, and remove_first. { ACE_TRACE ("ACE_Timer_Hash_T::is_empty"); return this->table_[this->earliest_position_]->is_empty (); }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Queue_Iterator_T< TYPE, FUNCTOR, ACE_LOCK > & ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::iter (  void    )  [virtual]

Returns a pointer to this <ACE_Timer_Queue>'s iterator. Implements ACE_Timer_Queue_T. Definition at line 191 of file Timer_Hash_T.cpp. References ACE_Timer_Hash_Iterator_T::first, and iterator_. Referenced by cancel. { this->iterator_->first (); return *this->iterator_; }

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

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Node_T< TYPE > * ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::remove_first (  void    )  [virtual]

Removes the earliest node from the queue and returns it. Implements ACE_Timer_Queue_T. Definition at line 532 of file Timer_Hash_T.cpp. References earliest_position_, find_new_earliest, is_empty, size_, and table_. { if (this->is_empty ()) return 0; ACE_Timer_Node_T<TYPE> *temp = this->table_[this->earliest_position_]->remove_first (); this->find_new_earliest (); --this->size_; return temp; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> void ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::reschedule (  ACE_Timer_Node_T< TYPE > *    )  [private, virtual]

Reschedule an "interval" <ACE_Timer_Node>. Implements ACE_Timer_Queue_T. Definition at line 324 of file Timer_Hash_T.cpp. References ACE_TRACE, earliest_position_, ACE_Timer_Node_T::get_act, ACE_Timer_Node_T::get_interval, ACE_Timer_Node_T::get_timer_value, ACE_Timer_Node_T::get_type, Hash_Token::orig_id_, ACE_Time_Value::sec, table_, and table_size_. Referenced by expire. { ACE_TRACE ("ACE_Timer_Hash_T::reschedule"); size_t position = expired->get_timer_value ().sec () % this->table_size_; Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, ACE_const_cast (void *, expired->get_act ())); h->orig_id_ = this->table_[position]->schedule (expired->get_type (), h, expired->get_timer_value (), expired->get_interval ()); if (this->table_[this->earliest_position_]->is_empty () || this->table_[position]->earliest_time () < this->table_[this->earliest_position_]->earliest_time ()) this->earliest_position_ = position; }

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> int ACE_Timer_Hash_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET >::reset_interval (  long    timer_id, const ACE_Time_Value &    interval )  [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_Timer_Queue_T. Definition at line 402 of file Timer_Hash_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_TRACE, Hash_Token::orig_id_, Hash_Token::pos_, and table_. { ACE_TRACE ("ACE_Timer_Hash_T::reset_interval"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Make sure we are getting a valid <timer_id>, not an error // returned by <schedule>. if (timer_id == -1) return -1; #if defined (ACE_WIN64) unsigned long timer_offset = ACE_static_cast (unsigned long, timer_id); Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, (this->pointer_base_ + timer_offset)); #else Hash_Token *h = ACE_reinterpret_cast (Hash_Token *, timer_id); #endif /* ACE_WIN64 */ return this->table_[h->pos_]->reset_interval (h->orig_id_, interval); }

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

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 is a pointer to a token which stores information about the event. This <timer_id> can be used to cancel the timer before it expires. Returns -1 on failure. Implements ACE_Timer_Queue_T. Definition at line 350 of file Timer_Hash_T.cpp. References ACE_GUARD_RETURN, ACE_MT, ACE_NEW_RETURN, ACE_TRACE, earliest_position_, Hash_Token::orig_id_, ACE_Time_Value::sec, size_, table_, and table_size_. { ACE_TRACE ("ACE_Timer_Hash_T::schedule"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); size_t position = future_time.sec () % this->table_size_; Hash_Token *h; ACE_NEW_RETURN (h, Hash_Token (act, position, 0), -1); h->orig_id_ = this->table_[position]->schedule (type, h, future_time, interval); if (this->table_[this->earliest_position_]->is_empty () || this->table_[position]->earliest_time () < this->table_[this->earliest_position_]->earliest_time ()) this->earliest_position_ = position; ++this->size_; #if defined (ACE_WIN64) // This is a Win64 hack, necessary because of the original (bad) decision // to use a pointer as the timer ID. This class doesn't follow the usual // timer expiration rules (see comments in header file) and is probably // not used much. The dynamic allocation of Hash_Tokens without // recording them anywhere is a large problem for Win64 since the // size of a pointer is 64 bits, but a long is 32. Since this class // is not much used, I'm hacking this, at least for now. If it becomes // an issue, I'll look at it again then. ptrdiff_t hi = ACE_reinterpret_cast (ptrdiff_t, h); if (this->pointer_base_ == 0) this->pointer_base_ = hi & 0xffffffff00000000; return ACE_reinterpret_cast (long, hi & 0xffffffff); #else return ACE_reinterpret_cast (long, h); #endif }

---

Friends And Related Function Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> friend class ACE_Timer_Hash_Iterator_T< TYPE, FUNCTOR, ACE_LOCK, BUCKET > [friend]

Iterator is a friend. Definition at line 136 of file Timer_Hash_T.h.

---

Member Data Documentation

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> size_t ACE_Timer_Hash_T::earliest_position_ [private]

Index to the position with the earliest entry. Definition at line 264 of file Timer_Hash_T.h. Referenced by cancel, earliest_time, find_new_earliest, get_first, is_empty, remove_first, reschedule, and schedule.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> HASH_ITERATOR* ACE_Timer_Hash_T::iterator_ [private]

Iterator used to expire timers. Definition at line 267 of file Timer_Hash_T.h. Referenced by ACE_Timer_Hash_T, iter, and ~ACE_Timer_Hash_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> size_t ACE_Timer_Hash_T::size_ [private]

Keeps track of the size of the queue. Definition at line 252 of file Timer_Hash_T.h. Referenced by cancel, expire, remove_first, and schedule.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> BUCKET** ACE_Timer_Hash_T::table_ [private]

Table of BUCKETS. Definition at line 255 of file Timer_Hash_T.h. Referenced by ACE_Timer_Hash_T, cancel, dump, earliest_time, expire, find_new_earliest, get_first, is_empty, remove_first, reschedule, reset_interval, schedule, and ~ACE_Timer_Hash_T.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK> ACE_Timer_Hash_T::table_functor_ [private]

Functor used for the table's timer queues. Definition at line 261 of file Timer_Hash_T.h.

template<class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET> size_t ACE_Timer_Hash_T::table_size_ [private]

Keeps track of the size of table_. Definition at line 258 of file Timer_Hash_T.h. Referenced by ACE_Timer_Hash_T, cancel, dump, expire, find_new_earliest, reschedule, schedule, and ~ACE_Timer_Hash_T.

---

The documentation for this class was generated from the following files:

• Timer_Hash_T.h
• Timer_Hash_T.cpp

---