sim_time.hpp

RFID reader 语 tag 模拟器

 #ifndef SIM_TIME_H
 #define SIM_TIME_H

 #include <iostream>
 using namespace std;

 #include <boost/shared_ptr.hpp>

 class SimTime {
 public:

    SimTime();
    SimTime(double simTime);

    inline void setTimeInMicroSeconds(double timeInMicroSeconds);

    inline void setTimeInMilliSeconds(double timeInMilliSeconds);

    inline void setTimeInSeconds(double timeInSeconds);

    inline void setTimeInMinutes(double timeInMinutes);

    inline double getTimeInMicroSeconds() const;

    inline double getTimeInMilliSeconds() const;

    inline double getTimeInSeconds() const;

    inline double getTimeInMinutes() const;

    inline void setTime(double timeInSeconds);

    inline double getTime() const;

    inline bool isValid() const;


    inline SimTime& operator+= (const SimTime& rhs);
    inline SimTime& operator-= (const SimTime& rhs);
    inline bool operator< (const SimTime& rhs) const;
    inline bool operator<= (const SimTime& rhs) const;
    inline bool operator> (const SimTime& rhs) const;
    inline bool operator>= (const SimTime& rhs) const;

 private:
    double m_time;
 };
 typedef boost::shared_ptr<SimTime> SimTimePtr;

 // Inline Functions

 inline void SimTime::setTimeInMicroSeconds(double timeInMicroSeconds)
 {
    assert(timeInMicroSeconds >= 0.0);
    m_time = (timeInMicroSeconds / 10.0);
 }

 inline void SimTime::setTimeInMilliSeconds(double timeInMilliSeconds)
 {
    assert(timeInMilliSeconds >= 0.0);
    m_time = (timeInMilliSeconds / 1000.0);
 }

 inline void SimTime::setTimeInSeconds(double timeInSeconds)
 {
    assert(timeInSeconds >= 0.0);
    m_time = timeInSeconds;
 }

 inline void SimTime::setTimeInMinutes(double timeInMinutes)
 {
    assert(timeInMinutes >= 0.0);
    m_time = (60.0 * timeInMinutes);
 }

 inline double SimTime::getTimeInMicroSeconds() const
 {
    return (10.0 * m_time);
 }

 inline double SimTime::getTimeInMilliSeconds() const
 {
    return (1000.0 * m_time);
 }

 inline double SimTime::getTimeInSeconds() const
 {
    return m_time;
 }

 inline double SimTime::getTimeInMinutes() const
 {
    return (m_time / 60.0);
 }

 inline void SimTime::setTime(double timeInSeconds)
 {
    setTimeInSeconds(timeInSeconds);
 }

 inline double SimTime::getTime() const
 {
    return getTimeInSeconds();
 }

 inline bool SimTime::isValid() const
 {
    // Right now, our only requirement is that
    // the time is not negative.
    return (m_time >= 0.0);
 }

 // Overloaded Operators

 inline SimTime& SimTime::operator+= (const SimTime& rhs)
 {
    m_time += rhs.m_time;
    return *this;
 }

 inline SimTime& SimTime::operator-= (const SimTime& rhs)
 {
    m_time -= rhs.m_time;
    return *this;
 }

 inline bool SimTime::operator< (const SimTime& rhs) const
 {
    return m_time < rhs.m_time;
 }

 inline bool SimTime::operator<= (const SimTime& rhs) const
 {
    return m_time <= rhs.m_time;
 }

 inline bool SimTime::operator> (const SimTime& rhs) const
 {
    return m_time > rhs.m_time;
 }

 inline bool SimTime::operator>= (const SimTime& rhs) const
 {
    return m_time >= rhs.m_time;
 }

 // Note that this can't be included in the class definition, so we
 // define it here so that files that include sim_time.hpp can
 // use it.
 inline SimTime operator+ (const SimTime& lhs, const SimTime& rhs)
 {
    SimTime returnVal = lhs;
    return returnVal += rhs;
 }

 inline SimTime operator- (const SimTime& lhs, const SimTime& rhs)
 {
    SimTime returnVal = lhs;
    return returnVal -= rhs;
 }

 inline ostream& operator<< (ostream& s, const SimTime& st)
 {
    return s<< st.getTimeInSeconds();
 }

 #endif // SIM_TIME_H