#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