event.hpp

#ifndef EVENT_H
#define EVENT_H

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

#include "sim_time.hpp"
#include "utility.hpp"

class Event : boost::noncopyable {
   // Only Simulator can set the event time.
   friend class Simulator;
public:
   typedef boost::shared_ptr<Event> EventPtr;

   virtual ~Event();

   virtual void execute() = 0;

   inline SimTime getFireTime() const;

   inline bool inEventQueue() const;

   // Needed for insertion in a priority_queue
   inline bool operator< (const Event& e) const;

protected:

   Event();

private:

   SimTime m_timeToFire;

   bool m_inEventQueue;

   inline void setFireTime(const SimTime& newFireTime);

   inline void setInEventQueue(const bool inEventQueue);

};
typedef boost::shared_ptr<Event> EventPtr;
typedef boost::shared_ptr<Event const> ConstEventPtr;

// Inline Functions

inline void Event::setFireTime(const SimTime& newFireTime) 
{
   m_timeToFire = newFireTime;
}

inline SimTime Event::getFireTime() const 
{
   return m_timeToFire;
}

inline bool Event::inEventQueue() const
{
   return m_inEventQueue;
}

inline void Event::setInEventQueue(const bool inEventQueue)
{
   m_inEventQueue = inEventQueue;
}

// Overloaded Operators

inline bool Event::operator< (const Event& e) const {
   return m_timeToFire < e.m_timeToFire; 
}

inline ostream& operator<< (ostream& s, const Event& event)
{
   return s<< "Event state (pointer=" << &event << ", time=" <<
      event.getFireTime() << ")";
}

// Subclasses

class DummyEvent : public Event {
public:
   typedef boost::shared_ptr<DummyEvent> DummyEventPtr;

   static inline DummyEventPtr create()
   {
      DummyEventPtr p(new DummyEvent());
      return p;
   }

   void execute()
   {
      /*
      cout << "Executing event " << this << " at time " << 
         getFireTime() << ".\n";
      */
   }
protected:

   DummyEvent() 
      : Event() 
   {
   
   }
};
typedef boost::shared_ptr<DummyEvent> DummyEventPtr;

#endif // EVENT_H

---