timer.hpp

#ifndef TIMER_H
#define TIMER_H

#include <iostream>
using namespace std;
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>

#include "node.hpp"
#include "event.hpp"
#include "sim_time.hpp"

class Timer : boost::noncopyable {
public:
   typedef boost::shared_ptr<Timer> TimerPtr;

   static inline TimerPtr create(NodePtr owner, EventPtr eventOnFire);

   inline bool start(const SimTime& delay) const;

   inline bool stop() const;

   inline bool reschedule(const SimTime& delay) const;

   inline bool isRunning() const;

   inline SimTime timeRemaining() const;

   void setEvent(const EventPtr eventOnFire);

protected:

   Timer(NodePtr owner, EventPtr eventOnFire);

private:

   NodePtr m_owner;

   EventPtr m_eventOnFire;

};
typedef boost::shared_ptr<Timer> TimerPtr;

// Inline Functions

inline TimerPtr Timer::create(NodePtr owner, EventPtr eventOnFire)
{
   TimerPtr p(new Timer(owner, eventOnFire));
   return p;
}

inline bool Timer::start(const SimTime& delay) const
{
   assert(m_owner != 0);
   assert(m_eventOnFire != 0);

   bool didScheduleEvent = false;
   if(!isRunning()) {
      didScheduleEvent = m_owner->scheduleEvent(m_eventOnFire, delay);
   }
   return didScheduleEvent;
}

inline bool Timer::stop() const
{
   assert(m_owner != 0);
   assert(m_eventOnFire != 0);

   bool didCancelEvent = false;
   if(isRunning()) {
      didCancelEvent = m_owner->cancelEvent(m_eventOnFire);
   }
   return didCancelEvent;
}

inline bool Timer::reschedule(const SimTime& delay) const
{
   bool wasSuccessful = true;
   if(isRunning()) {
      wasSuccessful &= stop();
   }
   wasSuccessful &= start(delay);

   return wasSuccessful;

}

inline bool Timer::isRunning() const
{
   assert(m_eventOnFire != 0);
   return m_eventOnFire->inEventQueue();
}

inline SimTime Timer::timeRemaining() const
{
   assert(m_owner != 0);
   assert(m_eventOnFire != 0);

   SimTime timeLeft(0.0);
   if(isRunning()) {
      timeLeft = m_eventOnFire->getFireTime() - m_owner->currentTime();
      assert(timeLeft.isValid());
   }

   return timeLeft;
}

// Overloaded Operators

inline ostream& operator<< (ostream& s, const Timer& timer)
{
   return s<< "Timer state (pointer=" << &timer << ") isRunning=" <<
      timer.isRunning() << " timeRemaining=" << timer.timeRemaining();
}

#endif // TIMER_H

---