Timer.h

#ifndef TIMER_H
#define TIMER_H 1

#include <omnetpp.h>

#include "TimerCore.h"

/* Usage:
 * Your class needs to be a subclass of Timer (as well as BaseWhatever),
 * call Timer::init(self) before doing anything, and override handleTimer()
 * to do whatever things need doing when timers fire.
 *
 * The Timer module will also auto-cleanup all leftover timers at the end of 
 * simulation, but deleteTimer can be used to reclaim memory.
 *
 * Example (for a localisation module extending BaseLocalisation):
 *
 * class MyClass: public BaseLocalisation, public Timer
 * {
 *     public:
 *      //Module_Class_Members(MyClass, BaseLocalisation, 0)
 *      void initialize();
 *      void handleTimer(unsigned int index);
 * }
 *
 * void MyClass::initialize()
 * {
 *      Timer::init(self);
 *      setTimer(1.0);
 * }
 *
 * void MyClass::handleTimer(unsigned int index)
 * {
 *    // Do timer stuff, which will happen 
 *      // 1.0s after startup (see the setTimer above)
 * }
 */

class Timer
{
  friend class TimerCore;
  protected:
    TimerCore *ct;
    cModule *owner;

  public:
      Timer(){ct = NULL;owner=NULL;}
    virtual ~Timer(){delete ct;}
  
  virtual void init(cModule *parent);

  void setTimer(unsigned int index, simtime_t when){checkCT();ct->setTimer(index,when);}

  unsigned int setTimer(simtime_t when){checkCT();return ct->setTimer(when);}

  void cancelTimer(unsigned int index){checkCT();ct->cancelTimer(index);}

  float remainingTimer(unsigned int index) {checkCT();return ct->remainingTimer(index);}

  /* Timer "fire" handler routine. Needs to be overriden by classes that want to use Timer
   * @param index The timer number for the timer that has just completed
   */
  virtual void handleTimer(unsigned int index)=0;

  void setContextPointer(unsigned int index,void * data) {checkCT();ct->setContextPointer(index,data);}

  void * contextPointer(unsigned int index) {checkCT();return ct->contextPointer(index);}

  void setContextDestructor(unsigned int index, void (*func)(void * data)){checkCT();ct->setContextDestructor(index,func);}

  /* Mark the first @count pointer ids (from 0 to @count-1) as allocated, so they don't get
   * auto-allocated by setTimer
   * @param count Number of timers to allocate
   */
  void allocateTimers(unsigned int count) {checkCT();ct->allocateTimers(count);}

  /* Delete a timer. Useful for auto-allocated timers that you don't need any more to 
   * reduce memory usage. Does nothing if the timer doesn't exist, and works even if 
   * a timer is still running.
   *
   * This does not need to be called for every timer, as the Timer module will automatically cleanup
   * all of the remaining timers at the end of the simulation. It is a tool for reclaiming memory 
   * early for simulations that might need many timers, and would otherwise fill up all the free 
   * memory with old timers.
   * @param index Timer to wipe
   */
  void deleteTimer(unsigned int index) {checkCT();ct->deleteTimer(index);}

private: 
  /* checkCT is an internal check function to test if init() has been called */
  void checkCT() 
  {
    if (ct == NULL)
      opp_error("init() must be called before using Timer functions");
  }

};

#endif