SimTime.h

Go to the documentation of this file.

#ifndef TIME_H_
#define TIME_H_

#include <string>
using std::string;

#ifndef SWIG
  #include <iostream>
  using std::ostream;
  using std::cerr;
  using std::endl;
#endif

#include <limits>
#include <cmath>

#include <boost/format.hpp>

#include "PCSIMException.h"


#ifndef SWIG

namespace PCSIM
{
    class TimeException : public Exception
    {
    public:
        TimeException( string method, string msg ) :  Exception( method, msg ) {};
        virtual string name() const { return string("PCSIM::TimeException"); };
    };

    class TimeRangeException : public TimeException
    {
    public:
        TimeRangeException( string method, string msg ) :  TimeException( method, msg ) {};
        virtual string name() const { return string("PCSIM::TimeRangeException"); };
    };

}

#endif

typedef long long tic_t;
typedef unsigned long step_t;

class Time
{
public:

    Time() : _tics(0) {} ;
    Time(const Time& t) : _tics(t._tics) {};

    static Time ticks(tic_t t);
    static Time steps(const step_t s, const Time &dt);
    static Time ms(double t);
    static Time sec(double t);

    tic_t  in_tics() const;
    step_t in_steps(const Time &dt) const;
    double in_ms() const;
    double in_sec() const;

#ifndef SWIG
    
    string toString() const;

    bool operator==(const Time& t) const;
    bool operator!=(const Time& t) const;
    bool operator<=(const Time& t) const;
    bool operator<(const Time& t) const;
    bool operator>=(const Time& t) const;
    bool operator>(const Time& t) const;

    Time operator+=(const Time& t);
    Time operator-=(const Time& t);
    Time operator+(const Time& t);
    Time operator-(const Time& t);

#endif
    
private:

    static const double _sec_per_tic;
    static const double _tics_per_sec;
    static const double _ms_per_tic;
    static const double _tics_per_ms;

    static step_t tics2steps(const tic_t tics, const Time &dt);
    static tic_t steps2tics(const step_t s, const Time &dt);

    static double tics2ms(const tic_t tics);
    static tic_t ms2tics(const double ms);

    static double tics2sec(const tic_t tics);
    static tic_t sec2tics(const double sec);

    tic_t _tics;
};

inline Time Time::ticks(tic_t t)
{
    Time T;
    T._tics = t;
    return T;
}

inline Time Time::steps(step_t s, const Time &dt)
{
    Time t;
    t._tics = steps2tics(s,dt);
    return t;
}

inline Time Time::ms(double s)
{
    Time t;
    t._tics = ms2tics(s);
    return t;
}
inline Time Time::sec(double s)
{
    Time t;
    t._tics = sec2tics(s);
    return t;
}

inline tic_t Time::in_tics() const
{
    return _tics;
}

inline step_t Time::in_steps(const Time &dt) const
{
    return tics2steps(_tics,dt);
}

inline double Time::in_ms() const
{
    return tics2ms(_tics);
}

inline double Time::in_sec() const
{
    return tics2sec(_tics);
}

inline string Time::toString() const
{
    return str( boost::format( "%1% ms" ) % in_ms() );
}

inline bool Time::operator==(const Time& other) const
{
    return this->_tics == other._tics;
}

inline bool Time::operator!=(const Time& other) const
{
    return this->_tics != other._tics;
}

inline bool Time::operator<=(const Time& t) const
{
    return this->_tics <= t._tics;
}

inline bool Time::operator<(const Time& t) const
{
    return this->_tics < t._tics;
}

inline bool Time::operator>=(const Time& t) const
{
    return this->_tics >= t._tics;
}

inline bool Time::operator>(const Time& t) const
{
    return this->_tics > t._tics;
}

inline Time Time::operator+=(const Time& t1)
{
    tic_t nt = _tics + t1._tics;
    if( (_tics>0) && (t1._tics>0) && (nt<_tics)) {
        cerr << toString() << " + " << t1.toString() << endl;
        throw( PCSIM::TimeRangeException( "Time::operator+=" , "Overflow" ) );
    } else  if( (_tics<0) && (t1._tics<0) && (nt>_tics))
        throw( PCSIM::TimeRangeException( "Time::operator+=" , "Underflow" ) );
    _tics = nt;
    return *this;
}

inline Time Time::operator-=(const Time& t1)
{
    Time r = t1;
    r._tics *= -1;
    *this += r;
    return r;
}

inline Time Time::operator+(const Time& t)
{
    Time res(*this);
    res += t;
    return res;
}

inline Time Time::operator-(const Time& t)
{
    Time res(*this);
    res -= t;
    return res;
}

#ifndef SWIG

inline ostream& operator<<(ostream &s, const Time &t)
{
    return s << t.toString();
}

#endif

inline step_t Time::tics2steps(const tic_t tics, const Time &dt)
{
    step_t steps=(step_t)round(tics/dt._tics);

    if( (tics % dt._tics) != 0 ) {
        //throw( PCSIM::TimeException( "Time::tics2step", "Trunctation: Given number of ticks not a multiple of tics_per_step!" ) );
    }
   return steps;
}

inline tic_t Time::steps2tics(const step_t s, const Time &dt)
{
    return dt._tics * static_cast<tic_t>(s);
}

inline double Time::tics2ms(const tic_t tics)
{
    return _ms_per_tic*static_cast<double>(tics);
}

inline tic_t Time::ms2tics(double ms)
{
    return static_cast<tic_t>(std::floor(ms*_tics_per_ms+0.5));
}

inline double Time::tics2sec(const tic_t tics)
{
    return _sec_per_tic*static_cast<double>(tics);
}

inline tic_t Time::sec2tics(double sec)
{
    return static_cast<tic_t>(std::floor(sec*_tics_per_sec+0.5));
}

#endif /*TIME_H_*/

---