基于ACE的定时器模板类

 ACETimerClockGenerator.h
 ClockGeneratorIF.h
 在类中定义一个结构体，在结构体中定义一个函数。
 在结构体中定义一个函数，这样做有什么好呢？

 TimerHandler.h
 用了模板的方法去构造定时器类。有助于底层调用上层。在构造的时候就初始化一个类中最大的定时器个数，及模板类（也就是parent）。
     TimerHandler(T *parent, int numTimers) : timers(numTimers, -)
     { //初始化向量，赋值给私有的成员变量。
         this->parent = parent;
         this->numTimers = numTimers;
 }

 用到了STL向量：
 std::vector<int> timers;

 ACE中
 .    startTimer（int timerType, const ACE_Time_Value &delay）
 ACE_Reactor::instance()->schedule_timer()
 .    stopTimer（int timerType）
 ACE_Reactor::instance()->cancel_timer(timers[timerType]);
 .    showTimers（bool showAll）
   ACE_Timer_Queue *reactor_timerQ =  ACE_Reactor::instance()->timer_queue();
       ACE_Timer_Queue_Iterator &iter = reactor_timerQ->iter();

 #ifndef _TimerHandler_h
 #define _TimerHandler_h

 #include <vector>
 #include "ace/Timer_Queue.h"
 #include "ace/Date_Time.h"
 #include "ace/Event_Handler.h"
 #include "ace/Reactor.h"

 #include "TraceUtils.h"

 template <class T>
 class TimerHandler : public ACE_Event_Handler
 {
     std::vector<int> timers;
     T *parent;
     int numTimers;
   public:
     TimerHandler(T *parent, int numTimers) : timers(numTimers, -)
     {
         this->parent = parent;
         this->numTimers = numTimers;
     }

     ~TimerHandler()
     {
         for (unsigned int i = ; i < timers.size(); i++)
         {
             if (timers[i] != -)
                 ACE_Reactor::instance()->cancel_timer(timers[i]);
         }
     }

     int handle_timeout (const ACE_Time_Value &current_time,
                         const void *arg)
     {
         long int timerType = (long int)arg;
         timers[timerType] = -;
         parent->handleTimeout(timerType);
         return ;
     }

     int startTimer(int timerType, const ACE_Time_Value &delay)
     {
         if (timerType > numTimers-) // No such timer type
             return -;
         if (timerType < )
             return -;
         if (timers[timerType] != -)      // Timer already running
             return -;
         timers[timerType] =
             ACE_Reactor::instance()->schedule_timer(this,
                                                     (const void *)timerType,
                                                     delay);
         return timers[timerType];
     }

     int stopTimer(int timerType)
     {
         if (timerType > numTimers- || // No such timer type
             timerType <  ||
             timers[timerType] == -)      // Timer not already running
             return -;
         ACE_Reactor::instance()->cancel_timer(timers[timerType]);
         timers[timerType] = -;
         return ;
     }

     bool timerStarted (int timerType)
     {
         return (timers[timerType] != -);
     }

     void showTimers(bool showAll)
     {
         ACE_Timer_Queue *reactor_timerQ =  ACE_Reactor::instance()->timer_queue();
         ACE_Timer_Queue_Iterator &iter = reactor_timerQ->iter();

         if (reactor_timerQ->is_empty())
         {
             TRACE_DEBUG("No Timers in Queue\n");
         }

         int total_timers=, hndlr_timers=;

         TRACE_DEBUG("Timers in queue:\n");
         for (; !iter.isdone (); iter.next ())
         {
             ACE_Timer_Node *tn = iter.item ();

             total_timers++;
             if (tn->get_type() == this)
                 hndlr_timers++;

             if (showAll || (tn->get_type() == this))
             {
                 char          str[];
                 ACE_Date_Time dt;

                 dt.update(tn->get_timer_value());
                 sprintf(str,
                         "%02ld/%02ld/%04ld %02ld:%02ld:%02ld.%03ld",
                         dt.day(),
                         dt.month(),
                         dt.year(),
                         dt.hour(),
                         dt.minute(),
                         dt.second(),
                         dt.microsec() / );
                 TRACE_DEBUG("Timer Id #%d: Hndlr=0x%x, Timer/Act: %ld, Interval: %d, Expiry= %s\n",
                             tn->get_timer_id (),
                             tn->get_type(),
                             (long int)tn->get_act(),
                             tn->get_interval().sec(),
                             str);
             }
         }

         char          str[];
         ACE_Date_Time dt;
         dt.update(reactor_timerQ->earliest_time());

         sprintf(str,
                 "%02ld/%02ld/%04ld %02ld:%02ld:%02ld.%03ld",
                 dt.day(),
                 dt.month(),
                 dt.year(),
                 dt.hour(),
                 dt.minute(),
                 dt.second(),
                 dt.microsec() / );            

         TRACE_INFO("Total Timers= %d, Timers for Handler[ 0x%x ]= %d, Skew=%d, Earliest= %s\n",
                    total_timers, this, hndlr_timers, reactor_timerQ->timer_skew().sec(), str);

         return;
     }
 };

 template <class T>
 class subTimerHandler : public ACE_Event_Handler
 {
     std::vector<int> timers;
     T *parent;
     int numTimers;
   public:
     subTimerHandler(T *parent, int numTimers) : timers(numTimers, -)
     {
         this->parent = parent;
         this->numTimers = numTimers;
     }

     subTimerHandler()
     {
         for (unsigned int i = ; i < timers.size(); i++)
         {
             if (timers[i] != -)
                 ACE_Reactor::instance()->cancel_timer(timers[i]);
         }
     }

     int handle_timeout (const ACE_Time_Value &current_time,
                         const void *arg)
     {
         long int timerType = (long int)arg;
         timers[timerType] = -;
         parent->handleSubTimeout(timerType);
         return ;
     }

     int startTimer(int timerType, const ACE_Time_Value &delay)
     {
         if (timerType > numTimers-) // No such timer type
             return -;
         if (timerType < )
             return -;
         if (timers[timerType] != -)      // Timer already running
             return -;
         timers[timerType] =
             ACE_Reactor::instance()->schedule_timer(this,
                                                     (const void *)timerType,
                                                     delay);
         return timers[timerType];
     }

     int stopTimer(int timerType)
     {
         if (timerType > numTimers- || // No such timer type
             timerType <  ||
             timers[timerType] == -)      // Timer not already running
             return -;
         ACE_Reactor::instance()->cancel_timer(timers[timerType]);
         timers[timerType] = -;
         return ;
     }

     bool timerStarted (int timerType)
     {
         return (timers[timerType] != -);
     }

 };

 #endif /* _TimerHandler_h */