sim_time.hpp

#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 / 1000000.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 (1000000.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

---