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