title: C++ Timer class, also usage in QNX with pulse message
body: <p>I wrote a timer class for my project. I used standard C++ function calls for it.</p>
  
  <p>I want to create a timer (start, stop, pause, continue, reset) it and also pass it new timings.</p>
  
  <p>If the timer fires before I stop it, I want to get a qnx pulse message on a given channel.</p>
  
  <p>This is the header:</p>
  
  <pre><code>#ifndef TIMER_H_
  #define TIMER_H_
  
  #include &lt;time.h&gt;
  #include &lt;sys/neutrino.h&gt;
  #include "HWaccess.h"
  #include "address.h"
  
  #define MILLISECONDS_NANOSECONDS_CONV   1000000
  #define SECONDS_MILLISECONDS_CONV       1000
  
  class Timer {
  public:
      /**
       * Constructor creates a new timer, attaches to the given
       * channel.
       * Does not start timer!
       *
       * @param chid
       * @param seconds
       * @param milliseconds
       * @param msg
       */
      Timer(int chid, int sec, int msec, int msg);
  
      /**
       * Deletes timer after detach from channel
       */
      virtual ~Timer();
  
      /**
       * Starts the timer
       */
      void start();
  
      /**
       * Stops timer and resets it to initial values
       */
      void stop();
  
      /**
       * Pauses the timer
       */
      void pause();
  
      /**
       * Continues the timer
       */
      void cont();
  
      /**
       * Resets the timer to initial values
       */
      void reset();
  
      /**
       * Changes timer values to new given values and
       * resets it
       * Does not start the timer!
       *
       * @param seconds
       * @param milliseconds
       */
      void changeTime(int sec, int msec);
  
  private:
      /**
       * Timer ID
       */
      timer_t timerid;
  
      /**
       * Timerstruct for running timer
       */
      struct itimerspec timer;
  
      /**
       * Timerstruct for backing up the running timer
       */
      struct itimerspec backupTimer;
  
      /**
       * timer value: seconds
       */
      int seconds;
  
      /**
       * timer value: milliseconds
       */
      int miliSeconds;
  
      /**
       * Connection ID for timeout pulse
       */
      int coid;
  
      /**
       * Event structure for timer if it fires
       */
      struct sigevent event;
  };
  
  #endif /* TIMER_H_ */
  </code></pre>
  
  <p>...and the implementation:</p>
  
  <pre><code>#include "Timer.h"
  
  Timer::Timer(int chid, int sec, int msec, int msg) {
      if ((coid = ConnectAttach(0, 0, chid, _NTO_SIDE_CHANNEL, 0)) == -1) {
          printf("Timer: Error in ConnectAttach\n");
      }
  
      SIGEV_PULSE_INIT(&amp;event, coid, SIGEV_PULSE_PRIO_INHERIT, PULSE_FROM_TIMER, msg/*Timer abgelaufen*/);
  
      if (timer_create(CLOCK_REALTIME, &amp;event, &amp;timerid) == -1) {
          printf("Timer: Error in timer_create()\n");
      }
  
      seconds = sec;
      miliSeconds = msec;
  
      reset();
  }
  
  Timer::~Timer() {
      if (ConnectDetach(coid) == -1) {
          printf("Timer: Error in ConnectDetach\n");
      }
  
      if (timer_delete(timerid) == -1) {
          printf("Timer: Error in timer_delete()\n");
      }
  }
  
  void Timer::start() {
      if(timer_settime(timerid, 0, &amp;timer, NULL) == -1){
          printf("Timer: Error in timer_settime()\n");
      }
  }
  
  void Timer::stop() {
      // stop timer
      timer.it_value.tv_sec = 0;
      timer.it_value.tv_nsec = 0;
      timer.it_interval.tv_sec = 0;
      timer.it_interval.tv_nsec = 0;
      if(timer_settime(timerid, 0, &amp;timer, NULL) == -1){
          printf("Timer: Error in timer_settime()\n");
      }
  
      // reset it
      reset();
  }
  
  void Timer::pause() {
      timer.it_value.tv_sec = 0;
      timer.it_value.tv_nsec = 0;
      timer.it_interval.tv_sec = 0;
      timer.it_interval.tv_nsec = 0;
  
      // backup running timer values
      if(timer_gettime(timerid, &amp;backupTimer) == -1){
          printf("Timer: Error in timer_gettime()\n");
      }
      // disarm 
      if(timer_settime(timerid, 0, &amp;timer, NULL) == -1){
          printf("Timer: Error in timer_settime()\n");
      }
  }
  
  void Timer::cont() {
      // recover old values
      timer = backupTimer;
      // Arm timer
      if(timer_settime(timerid, 0, &amp;timer, NULL) == -1) {
          printf("Timer: Error in timer_settime()\n");
      }
  }
  
  void Timer::reset(){
      timer.it_value.tv_sec = seconds;
      timer.it_value.tv_nsec = miliSeconds * MILLISECONDS_NANOSECONDS_CONV;
      timer.it_interval.tv_sec = 0;
      timer.it_interval.tv_nsec = 0;
  }
  
  void Timer::changeTime(int sec, int msec){
      seconds = sec;
      miliSeconds = msec;
      reset();
  }
  </code></pre>
  
  <p>1) Can I set the timer struct's values to zero (to stop the timer) and backup the values in another back struct the way I am doing it? Or is the running timer decremented in the timer struct?</p>
  
  <p>2) Can i easily restore the old timer values with a simple <code>timer = backupTimer</code>?</p>
  
  <p>3) And finally, if I create and start a timer in a function, something like this:</p>
  
  <pre><code>void coolClass::interestingFunction() {
      //do other time consuming stuff here...
      Timer timer(chid, 10, 0);
      timer.start();
  }
  </code></pre>
  
  <p>... then the timer is created on the stack and when I exit this function (and its variables etc.) are no longer valid. Will the timer still count down and fire my pulse? Or will I have to use a classifier in my header file for this timer?</p>