/// 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_;
}
