simulator.hpp

#ifndef SIMULATOR_H
#define SIMULATOR_H

#include <vector>
#include <set>
using namespace std;
#include <boost/utility.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

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

class RandNumGenerator;
typedef boost::shared_ptr<RandNumGenerator> RandNumGeneratorPtr;
class LogStreamManager;
typedef LogStreamManager* LogStreamManagerPtr;

// EventPtrComparator Class

class EventPtrComparator {
public:
   inline bool operator() (ConstEventPtr event1, 
      ConstEventPtr event2) const;
};

inline bool EventPtrComparator::operator() (ConstEventPtr event1, 
   ConstEventPtr event2) const
{
   return *event1 < *event2;
}

// Simulator Class

typedef multiset<EventPtr,EventPtrComparator> EventPtrQueue;
typedef EventPtrQueue::iterator EventPtrQueueIterator;

// Declare as noncopyable so the copy constructor and copy 
// assignment cannot be used.
class Simulator : boost::noncopyable, 
      public boost::enable_shared_from_this<Simulator> {
public:
   typedef Simulator* SimulatorPtr;

   static inline SimulatorPtr instance();

   inline void addNode(NodePtr nodeToAdd);

   void runSimulation(const SimTime& stopTime);

   inline SimTime currentTime() const;

   inline bool scheduleEvent(EventPtr eventToSchedule, 
      const SimTime& eventDelay);

   inline bool cancelEvent(EventPtr eventToCancel);

   inline void setLogStreamManager(
         LogStreamManagerPtr logStreamManager) const;

   inline LogStreamManagerPtr getLogStreamManager() const;

   void seedRandNumGenerator(const t_uint seed) const;

   inline RandNumGeneratorPtr getRandNumGenerator() const;

   void reset();

   inline void addSimulationEndListener(
      SimulationEndListenerPtr listener);

private:

   static const double m_SIM_START_TIME;

   static SimulatorPtr m_instance;

   SimTime m_clock;

   EventPtrQueue m_eventPtrQueue;

   LogStreamManagerPtr m_logStreamManagerPtr;

   RandNumGeneratorPtr m_randNumGeneratorPtr;

   vector<SimulationEndListenerPtr> m_simulationEndListeners;

   Simulator();

   ~Simulator();

   inline void dispatchEvent(EventPtr event);

   inline EventPtr getNextEvent();

};
typedef Simulator* SimulatorPtr;

// Inline Functions

inline SimTime Simulator::currentTime() const
{
   return m_clock;
}

inline void Simulator::addNode(NodePtr nodeToAdd)
{
   // May keep track of the nodes globally in the future.
}

inline bool Simulator::scheduleEvent(EventPtr eventToSchedule, 
   const SimTime& eventDelay)
{
   assert(eventToSchedule != 0);
   assert(!eventToSchedule->inEventQueue());
   assert(eventDelay >= 0.0);

   eventToSchedule->setFireTime(currentTime() + eventDelay);
   EventPtrQueue::const_iterator insertIterator = 
      m_eventPtrQueue.insert(eventToSchedule);
   bool didInsert = (insertIterator != m_eventPtrQueue.end());
   if(didInsert) {
      eventToSchedule->setInEventQueue(true);
   }
   
   return didInsert;

}

inline bool Simulator::cancelEvent(EventPtr eventToCancel)
{
   assert(eventToCancel != 0);

   // Get the range of elements that match this key (i.e.,
   // have the same fire time).
   pair<EventPtrQueueIterator,EventPtrQueueIterator> keyIteratorPair =
      m_eventPtrQueue.equal_range(eventToCancel);
      
   bool didErase = false;
   // If the key was not found, pair.first == pair.second
   for(EventPtrQueueIterator keyIterator = keyIteratorPair.first;
         keyIterator != keyIteratorPair.second; 
         ++keyIterator) {

      // If we iterator finds the pointer we want to delete,
      // then erase the element and return.
      if(*keyIterator == eventToCancel) {
         m_eventPtrQueue.erase(keyIterator);
         eventToCancel->setInEventQueue(false);
         didErase = true;
         break;
      }
   }

   return didErase;
}

inline RandNumGeneratorPtr Simulator::getRandNumGenerator() const
{
   assert(m_randNumGeneratorPtr != 0);
   return m_randNumGeneratorPtr;
}

inline LogStreamManagerPtr Simulator::getLogStreamManager() const
{
   assert(m_logStreamManagerPtr != 0);
   return m_logStreamManagerPtr;
}

inline SimulatorPtr Simulator::instance() 
{
   // See the Singleton design pattern for an explanation.
   if(m_instance == 0) {
      m_instance = new Simulator();
   }
   return m_instance;
}

inline void Simulator::dispatchEvent(EventPtr event)
{
   assert(event.get() != 0);
   SimTime fireTime = event->getFireTime();
   assert(m_clock <= fireTime);

   m_clock = fireTime;
   event->execute();
}

inline EventPtr Simulator::getNextEvent()
{
   EventPtr nextEvent (*m_eventPtrQueue.begin());
   m_eventPtrQueue.erase(m_eventPtrQueue.begin());
   nextEvent->setInEventQueue(false);
   return nextEvent;
}

inline void Simulator::addSimulationEndListener(
   SimulationEndListenerPtr listener)
{
   m_simulationEndListeners.push_back(listener);
}

#endif // SIMULATOR_H

---