ACE/ace/Timer_List_T.cpp

   1 #ifndef ACE_TIMER_LIST_T_C
   2 #define ACE_TIMER_LIST_T_C
   3
   4 #include "ace/Timer_List_T.h"
   5 #include "ace/Guard_T.h"
   6 #include "ace/Log_Category.h"
   7
   8 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   9 # pragma once
  10 #endif /* ACE_LACKS_PRAGMA_ONCE */
  11
  12
  13 // Default Constructor
  14
  15 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY>
  16 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::ACE_Timer_List_Iterator_T (List& lst)
  17   : list_ (lst)
  18 {
  19   this->first();
  20 }
  21
  22 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY>
  23 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::~ACE_Timer_List_Iterator_T ()
  24 {
  25 }
  26
  27 // Positions the iterator at the node right after the dummy node
  28
  29 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
  30 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::first ()
  31 {
  32   this->current_node_ = this->list_.get_first();
  33 }
  34
  35 // Positions the iterator at the next node in the Timer Queue
  36
  37 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
  38 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::next ()
  39 {
  40   // Make sure that if we are at the end, we don't wrap around
  41   if (! this->isdone())
  42     this->current_node_ = this->current_node_->get_next ();
  43   if (this->current_node_  == this->list_.head_)
  44     this->current_node_ = 0;
  45 }
  46
  47 // Returns true when we are at <head_>
  48
  49 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> bool
  50 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::isdone () const
  51 {
  52   return this->current_node_ == 0;
  53 }
  54
  55 // Returns the node at <position_> or 0 if we are at the end
  56
  57 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
  58 ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::item ()
  59 {
  60   if (! this->isdone())
  61     return this->current_node_;
  62   return 0;
  63 }
  64
  65 ///////////////////////////////////////////////////////////////////////////////
  66 ///////////////////////////////////////////////////////////////////////////////
  67
  68 // Return our instance of the iterator
  69
  70 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> ACE_Timer_Queue_Iterator_T<TYPE> &
  71 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::iter ()
  72 {
  73   this->iterator_->first ();
  74   return *this->iterator_;
  75 }
  76
  77 // Create an empty list.
  78
  79 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY>
  80 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::ACE_Timer_List_T (FUNCTOR* uf,
  81                     FreeList* fl,
  82                     TIME_POLICY const & time_policy)
  83   : Base_Timer_Queue (uf, fl, time_policy)
  84   , head_ (new ACE_Timer_Node_T<TYPE>)
  85   , id_counter_ (0)
  86 {
  87   ACE_TRACE ("ACE_Timer_List_T::ACE_Timer_List_T");
  88
  89   this->head_->set_next (this->head_);
  90   this->head_->set_prev (this->head_);
  91
  92   ACE_NEW (iterator_, Iterator(*this));
  93 }
  94
  95
  96 // Checks if list is empty.
  97
  98 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> bool
  99 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::is_empty () const
 100 {
 101   ACE_TRACE ("ACE_Timer_List_T::is_empty");
 102   return this->get_first_i() == 0;
 103 }
 104
 105
 106 // Returns earliest time in a non-empty list.
 107
 108 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> const ACE_Time_Value &
 109 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::earliest_time () const
 110 {
 111   ACE_TRACE ("ACE_Timer_List_T::earliest_time");
 112   ACE_Timer_Node_T<TYPE>* first = this->get_first_i();
 113   if (first != 0)
 114     return first->get_timer_value ();
 115   return ACE_Time_Value::zero;
 116 }
 117
 118
 119 // Remove all remaining items in the list.
 120
 121 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY>
 122 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::~ACE_Timer_List_T ()
 123 {
 124   ACE_TRACE ("ACE_Timer_List_T::~ACE_Timer_List_T");
 125   ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_));
 126
 127   delete iterator_;
 128
 129   this->close ();
 130
 131   // delete the dummy node
 132   delete this->head_;
 133 }
 134
 135 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> int
 136 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::close ()
 137 {
 138   ACE_TRACE ("ACE_Timer_List_T::close");
 139   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 140
 141   // Remove all remaining items in the list.
 142   if (!this->is_empty())
 143     {
 144       for (ACE_Timer_Node_T<TYPE>* n = this->get_first();
 145            n != this->head_;
 146            )
 147         {
 148           this->upcall_functor ().deletion (*this,
 149                                             n->get_type(),
 150                                             n->get_act());
 151
 152           ACE_Timer_Node_T<TYPE> *next =
 153             n->get_next ();
 154
 155           this->free_node (n);
 156
 157           n = next;
 158         }
 159     }
 160
 161   // Leave rest to destructor
 162   return 0;
 163 }
 164
 165 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
 166 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::dump () const
 167 {
 168 #if defined (ACE_HAS_DUMP)
 169   ACE_TRACE ("ACE_Timer_List_T::dump");
 170   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 171
 172   int count = 0;
 173
 174   ACE_Timer_Node_T<TYPE>* n = this->get_first_i();
 175   if (n != 0) {
 176     for (; n != this->head_; n = n->get_next()) {
 177       ++count;
 178     }
 179   }
 180
 181   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize_ = %d"), count));
 182   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 183 #endif /* ACE_HAS_DUMP */
 184 }
 185
 186
 187 // Reschedule a periodic timer.  This function must be called with the
 188 // lock held.
 189
 190 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
 191 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::reschedule (ACE_Timer_Node_T<TYPE>* n)
 192 {
 193   ACE_TRACE ("ACE_Timer_List_T::reschedule");
 194   this->schedule_i(n, n->get_timer_value());
 195 }
 196
 197
 198 // Insert a new handler that expires at time future_time; if interval
 199 // is > 0, the handler will be reinvoked periodically.
 200
 201 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> long
 202 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::schedule_i (const TYPE &type,
 203                                                        const void *act,
 204                                                        const ACE_Time_Value &future_time,
 205                                                        const ACE_Time_Value &interval)
 206 {
 207   ACE_TRACE ("ACE_Timer_List_T::schedule_i");
 208
 209   ACE_Timer_Node_T<TYPE>* n = this->alloc_node();
 210
 211   if (n != 0)
 212   {
 213     long id = this->id_counter_++;
 214
 215     if (id != -1) {
 216       n->set (type, act, future_time, interval, 0, 0, id);
 217       this->schedule_i (n, future_time);
 218     }
 219     return id;
 220   }
 221
 222   // Failure return
 223   errno = ENOMEM;
 224   return -1;
 225 }
 226
 227 /// The shared scheduling functionality between schedule() and reschedule()
 228 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
 229 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::schedule_i (ACE_Timer_Node_T<TYPE>* n,
 230                                                        const ACE_Time_Value& expire)
 231 {
 232   if (this->is_empty()) {
 233     n->set_prev(this->head_);
 234     n->set_next(this->head_);
 235     this->head_->set_prev(n);
 236     this->head_->set_next(n);
 237     return;
 238   }
 239
 240   // We always want to search backwards from the tail of the list, because
 241   // this minimizes the search in the extreme case when lots of timers are
 242   // scheduled for exactly the same time, and it also assumes that most of
 243   // the timers will be scheduled later than existing timers.
 244   ACE_Timer_Node_T<TYPE>* p = this->head_->get_prev();
 245   while (p != this->head_ && p->get_timer_value() > expire)
 246     p = p->get_prev();
 247
 248   // insert after
 249   n->set_prev(p);
 250   n->set_next(p->get_next());
 251   p->get_next()->set_prev(n);
 252   p->set_next(n);
 253 }
 254
 255 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY>
 256 ACE_Timer_Node_T<TYPE>*
 257 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::find_node (long timer_id) const
 258 {
 259   ACE_Timer_Node_T<TYPE>* n = this->get_first_i();
 260   if (n == 0)
 261     return 0;
 262
 263   for (; n != this->head_; n = n->get_next()) {
 264     if (n->get_timer_id() == timer_id) {
 265       return n;
 266     }
 267   }
 268   return 0;
 269 }
 270
 271 // Locate and update the inteval on the timer_id
 272 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> int
 273 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::reset_interval (long timer_id,
 274                                                            const ACE_Time_Value &interval)
 275 {
 276   ACE_TRACE ("ACE_Timer_List_T::reset_interval");
 277   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 278   ACE_Timer_Node_T<TYPE>* n = this->find_node(timer_id);
 279   if (n != 0) {
 280     n->set_interval(interval); // The interval will take effect the next time this node is expired.
 281     return 0;
 282   }
 283   return -1;
 284 }
 285
 286 // Locate and remove the single <ACE_Event_Handler> with a value of
 287 // @a timer_id from the timer queue.
 288 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> int
 289 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::cancel (long timer_id,
 290                                                    const void **act,
 291                                                    int skip_close)
 292 {
 293   ACE_TRACE ("ACE_Timer_List_T::cancel");
 294   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 295   ACE_Timer_Node_T<TYPE>* n = this->find_node(timer_id);
 296   if (n != 0)
 297     {
 298       if (act != 0)
 299         *act = n->get_act ();
 300
 301       // Call the close hooks.
 302       int cookie = 0;
 303
 304       // cancel_type() called once per <type>.
 305       this->upcall_functor ().cancel_type (*this,
 306                                            n->get_type (),
 307                                            skip_close,
 308                                            cookie);
 309
 310       // cancel_timer() called once per <timer>.
 311       this->upcall_functor ().cancel_timer (*this,
 312                                             n->get_type (),
 313                                             skip_close,
 314                                             cookie);
 315
 316       this->cancel_i (n);
 317
 318       return 1;
 319     }
 320
 321   return 0;
 322 }
 323
 324 // Locate and remove all values of <handler> from the timer queue.
 325 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> int
 326 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::cancel (const TYPE &type, int skip_close)
 327 {
 328   ACE_TRACE ("ACE_Timer_List_T::cancel");
 329
 330   int num_canceled = 0; // Note : Technically this can overflow.
 331
 332   int cookie = 0;
 333
 334   ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, -1));
 335
 336   if (!this->is_empty ())
 337     {
 338       for (ACE_Timer_Node_T<TYPE>* n = this->get_first();
 339            n != this->head_;
 340            )
 341         {
 342           if (n->get_type() == type) // Note: Typically Type is an ACE_Event_Handler*
 343             {
 344               ++num_canceled;
 345
 346               ACE_Timer_Node_T<TYPE>* tmp = n;
 347               n = n->get_next();
 348
 349               this->cancel_i (tmp);
 350             }
 351           else
 352             {
 353               n = n->get_next();
 354             }
 355         }
 356     }
 357
 358   // Call the close hooks.
 359
 360   // cancel_type() called once per <type>.
 361   this->upcall_functor ().cancel_type (*this,
 362                                        type,
 363                                        skip_close,
 364                                        cookie);
 365
 366   for (int i = 0;
 367        i < num_canceled;
 368        ++i)
 369     {
 370       // cancel_timer() called once per <timer>.
 371       this->upcall_functor ().cancel_timer (*this,
 372                                             type,
 373                                             skip_close,
 374                                             cookie);
 375     }
 376
 377   return num_canceled;
 378 }
 379
 380 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
 381 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::unlink (ACE_Timer_Node_T<TYPE>* n)
 382 {
 383   n->get_prev()->set_next(n->get_next());
 384   n->get_next()->set_prev(n->get_prev());
 385   n->set_prev(0);
 386   n->set_next(0);
 387 }
 388
 389 /// Shared subset of the two cancel() methods.
 390 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> void
 391 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::cancel_i (ACE_Timer_Node_T<TYPE>* n)
 392 {
 393   this->unlink (n);
 394   this->free_node (n);
 395 }
 396
 397 // Reads the first node on the list and returns it.
 398 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
 399 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::get_first ()
 400 {
 401   ACE_TRACE ("ACE_Timer_List_T::get_first");
 402   return this->get_first_i();
 403 }
 404
 405 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
 406 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::get_first_i () const
 407 {
 408   ACE_TRACE ("ACE_Timer_List_T::get_first_i");
 409   ACE_Timer_Node_T<TYPE>* first = this->head_->get_next();
 410   if (first != this->head_) // Note : is_empty() uses get_first()
 411     return first;
 412   return 0;
 413 }
 414
 415
 416 // Removes the first node on the list and returns it.
 417
 418 template <class TYPE, class FUNCTOR, class ACE_LOCK, typename TIME_POLICY> ACE_Timer_Node_T<TYPE> *
 419 ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK, TIME_POLICY>::remove_first ()
 420 {
 421   ACE_TRACE ("ACE_Timer_List_T::remove_first");
 422   ACE_Timer_Node_T<TYPE>* first = this->get_first();
 423   if (first != 0) {
 424     this->unlink(first);
 425     return first;
 426   }
 427   return 0;
 428 }
 429
 430 #endif /* ACE_TIMER_LIST_T_C */