simulator.hpp

RFID reader 语 tag 模拟器

 #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