// Locate and remove the single <ACE_Event_Handler> with a value of // @a timer_id from the timer queue. template <class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::cancel (long timer_id, const void **act, int skip_close) { ACE_TRACE ("ACE_Timer_List_T::cancel"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); ACE_Timer_Node_T<TYPE>* n = this->find_node(timer_id); if (n != 0) { if (act != 0) *act = n->get_act (); // Call the close hooks. int cookie = 0; // cancel_type() called once per <type>. this->upcall_functor ().cancel_type (*this, n->get_type (), skip_close, cookie); // cancel_timer() called once per <timer>. this->upcall_functor ().cancel_timer (*this, n->get_type (), skip_close, cookie); this->cancel_i (n); return 1; } return 0; }
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::~ACE_Timer_List_T (void) { ACE_TRACE ("ACE_Timer_List_T::~ACE_Timer_List_T"); ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); delete iterator_; if (!this->is_empty()) { for (ACE_Timer_Node_T<TYPE>* n = this->get_first(); n != this->head_; ) { this->upcall_functor ().deletion (*this, n->get_type(), n->get_act()); ACE_Timer_Node_T<TYPE> *next = n->get_next (); this->free_node (n); n = next; } } // delete the dummy node delete this->head_; }
template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> int ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::close (void) { ACE_TRACE ("ACE_Timer_List_T::close"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Remove all remaining items in the list. if (!this->is_empty()) { for (ACE_Timer_Node_T<TYPE>* n = this->get_first(); n != this->head_; ) { this->upcall_functor ().deletion (*this, n->get_type(), n->get_act()); ACE_Timer_Node_T<TYPE> *next = n->get_next (); this->free_node (n); n = next; } } // Leave rest to destructor return 0; }
template <class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::cancel (const TYPE &type, int dont_call) { ACE_TRACE ("ACE_Timer_List_T::cancel"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); int number_of_cancellations = 0; for (ACE_Timer_Node_T<TYPE> *curr = this->head_->get_next (); curr != this->head_; ) { if (curr->get_type () == type) { number_of_cancellations++; curr->get_prev ()->set_next (curr->get_next ()); curr->get_next ()->set_prev (curr->get_prev ()); ACE_Timer_Node_T<TYPE> *temp = curr; curr = curr->get_next (); this->free_node (temp); } else curr = curr->get_next (); } if (dont_call == 0) this->upcall_functor ().cancellation (*this, type); return number_of_cancellations; }
// Locate and remove all values of <handler> from the timer queue. template <class TYPE, class FUNCTOR, class ACE_LOCK> int ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::cancel (const TYPE &type, int skip_close) { ACE_TRACE ("ACE_Timer_List_T::cancel"); int num_canceled = 0; // Note : Technically this can overflow. int cookie = 0; ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); if (!this->is_empty ()) { for (ACE_Timer_Node_T<TYPE>* n = this->get_first(); n != this->head_; ) { if (n->get_type() == type) // Note: Typically Type is an ACE_Event_Handler* { ++num_canceled; ACE_Timer_Node_T<TYPE>* tmp = n; n = n->get_next(); this->cancel_i (tmp); } else { n = n->get_next(); } } } // Call the close hooks. // cancel_type() called once per <type>. this->upcall_functor ().cancel_type (*this, type, skip_close, cookie); for (int i = 0; i < num_canceled; ++i) { // cancel_timer() called once per <timer>. this->upcall_functor ().cancel_timer (*this, type, skip_close, cookie); } return num_canceled; }
ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::~ACE_Timer_List_T (void) { ACE_TRACE ("ACE_Timer_List_T::~ACE_Timer_List_T"); ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); delete iterator_; for (ACE_Timer_Node_T<TYPE> *curr = this->head_->get_next (); curr != this->head_; ) { ACE_Timer_Node_T<TYPE> *next = curr->get_next (); this->upcall_functor ().deletion (*this, next->get_type (), next->get_act ()); this->free_node (curr); curr = next; } // delete the dummy node delete this->head_; }
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 &cur_time) { 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; }