timer.hpp

RFID reader 语 tag 模拟器

 #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