/// The shared scheduling functionality between schedule() and reschedule() template <class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::schedule_i (ACE_Timer_Node_T<TYPE>* n, const ACE_Time_Value& expire) { if (this->is_empty()) { n->set_prev(this->head_); n->set_next(this->head_); this->head_->set_prev(n); this->head_->set_next(n); return; } // We always want to search backwards from the tail of the list, because // this minimizes the search in the extreme case when lots of timers are // scheduled for exactly the same time, and it also assumes that most of // the timers will be scheduled later than existing timers. ACE_Timer_Node_T<TYPE>* p = this->head_->get_prev(); while (p != this->head_ && p->get_timer_value() > expire) p = p->get_prev(); // insert after n->set_prev(p); n->set_next(p->get_next()); p->get_next()->set_prev(n); p->set_next(n); }
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; }
template <class TYPE, class FUNCTOR, class ACE_LOCK> ACE_Timer_Node_T<TYPE> * ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::remove_first (void) { ACE_TRACE ("ACE_Timer_List_T::remove_first"); // remove the node and fix the pointers ACE_Timer_Node_T<TYPE> *temp = this->head_->get_next (); this->head_->set_next (temp->get_next ()); temp->get_next ()->set_prev (this->head_); return temp; }
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> long ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::schedule (const TYPE &type, const void *act, const ACE_Time_Value &future_time, const ACE_Time_Value &interval) { ACE_TRACE ("ACE_Timer_List_T::schedule"); ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1)); // Place in the middle of the list where it belongs (i.e., sorted in // ascending order of absolute time to expire). ACE_Timer_Node_T<TYPE> *after = this->head_->get_next (); while (after != this->head_ && future_time > after->get_timer_value ()) after = after->get_next (); ACE_Timer_Node_T<TYPE> *temp = this->alloc_node (); temp->set (type, act, future_time, interval, after->get_prev (), after, (long) temp); after->get_prev ()->set_next (temp); after->set_prev (temp); return ACE_reinterpret_cast (long, temp); }
ACE_Timer_Node_T<TYPE>* ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::find_node (long timer_id) const { ACE_Timer_Node_T<TYPE>* n = this->get_first_i(); if (n == 0) return 0; for (; n != this->head_; n = n->get_next()) { if (n->get_timer_id() == timer_id) { return n; } } return 0; }
template <class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::dump (void) const { ACE_TRACE ("ACE_Timer_List_T::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); size_t count = 0; for (ACE_Timer_Node_T<TYPE> *curr = this->head_->get_next (); curr != this->head_; curr = curr->get_next ()) count++; ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nsize_ = %d"), count)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntimer_id_ = %d"), this->timer_id_)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); }
template <class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::reschedule (ACE_Timer_Node_T<TYPE> *expired) { ACE_TRACE ("ACE_Timer_List_T::reschedule"); ACE_Timer_Node_T<TYPE> *after = this->head_->get_next (); // Locate the proper position in the queue. while (after != this->head_ && expired->get_timer_value () > after->get_timer_value ()) after = after->get_next (); expired->set_next (after); expired->set_prev (after->get_prev ()); after->get_prev ()->set_next (expired); after->set_prev (expired); }
template <class TYPE, class FUNCTOR, class ACE_LOCK> void ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK>::dump (void) const { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Timer_List_T::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); int count = 0; ACE_Timer_Node_T<TYPE>* n = this->get_first_i(); if (n != 0) { for (; n != this->head_; n = n->get_next()) { ++count; } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize_ = %d"), count)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }
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_; }