simtime.h

//==========================================================================
//   SIMTIME.H  - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __SIMTIME_H
#define __SIMTIME_H

#include <string>
#include <iostream>
#include "simkerneldefs.h"
#include "platdep/intxtypes.h"

NAMESPACE_BEGIN

class cPar;

// the most positive int64 value, represented as double
#define INT64_MAX_DBL  9.22337203685e18

enum SimTimeUnit
{
    SIMTIME_S  =  0,
    SIMTIME_MS = -3,
    SIMTIME_US = -6,
    SIMTIME_NS = -9,
    SIMTIME_PS = -12,
    SIMTIME_FS = -15
};

class SIM_API SimTime
{
  private:
    int64 t;

    static int scaleexp;     // scale exponent in the range -18..0
    static int64 dscale;     // 10^-scaleexp, that is 1 or 1000 or 1000000...
    static double fscale;    // 10^-scaleexp, that is 1 or 1000 or 1000000...
    static double invfscale; // 1/fscale; we store it because floating-point multiplication is faster than division

  protected:
    static void resetScale() {scaleexp = SCALEEXP_UNINITIALIZED;} // for unit tests only

  private:
    template<typename T> void check(T d) {if (scaleexp==SCALEEXP_UNINITIALIZED) initError(d);}
    void initError(double d);

    bool haveSameSign(int64 a, int64 b) { return (a^b) >= 0; }

    int64 toInt64(double i64) {
         if (fabs(i64) > INT64_MAX_DBL)
             rangeError(i64);
         return (int64)i64;
    }

    void checkedAdd(const SimTime& x) {
        // if operands are the same sign but result has different sign ==> overflow
        bool sameSign = haveSameSign(t, x.t);
        t += x.t;
        if (sameSign && !haveSameSign(t, x.t))
            overflowAdding(x);
    }

    void checkedSub(const SimTime& x) {
        // if operands are different signs and result has same sign as x ==> overflow
        bool differentSign = !haveSameSign(t, x.t);
        t -= x.t;
        if (differentSign && haveSameSign(t, x.t))
            overflowSubtracting(x);
    }

    void rangeError(double i64);
    void overflowAdding(const SimTime& x);
    void overflowSubtracting(const SimTime& x);

  public:
    // renamed constants (use SIMTIME_x instead)
    _OPPDEPRECATED static const int SCALEEXP_S;
    _OPPDEPRECATED static const int SCALEEXP_MS;
    _OPPDEPRECATED static const int SCALEEXP_US;
    _OPPDEPRECATED static const int SCALEEXP_NS;
    _OPPDEPRECATED static const int SCALEEXP_PS;
    _OPPDEPRECATED static const int SCALEEXP_FS;

    static const int SCALEEXP_UNINITIALIZED = 0xffff;

    SimTime() {t=0;}

    SimTime(double d) {operator=(d);}

    SimTime(cPar& d) {operator=(d);}

    // Note: a generic template constructor (commented out below) is not a good idea -- often causes surprises
    // template<typename T> SimTime(T d) {operator=(d);}

    SimTime(int64 significand, int exponent);

    SimTime(const SimTime& x) {operator=(x);}

    const SimTime& operator=(double d) {check(d); t=toInt64(fscale*d); return *this;}
    const SimTime& operator=(const cPar& d);
    const SimTime& operator=(const SimTime& x) {t=x.t; return *this;}
    template<typename T> const SimTime& operator=(T d) {check(d); t=toInt64(dscale*d); return *this;}

    const SimTime& operator+=(const SimTime& x) {checkedAdd(x); return *this;}
    const SimTime& operator-=(const SimTime& x) {checkedSub(x); return *this;}

    const SimTime& operator*=(double d) {t=toInt64(t*d); return *this;}
    const SimTime& operator/=(double d) {t=toInt64(t/d); return *this;}
    const SimTime& operator*=(const cPar& p);
    const SimTime& operator/=(const cPar& p);
    template<typename T> const SimTime& operator*=(T d) {t*=d; return *this;}
    template<typename T> const SimTime& operator/=(T d) {t/=d; return *this;}

    bool operator==(const SimTime& x) const  {return t==x.t;}
    bool operator!=(const SimTime& x) const  {return t!=x.t;}
    bool operator< (const SimTime& x) const  {return t<x.t;}
    bool operator> (const SimTime& x) const  {return t>x.t;}
    bool operator<=(const SimTime& x) const  {return t<=x.t;}
    bool operator>=(const SimTime& x) const  {return t>=x.t;}

    SimTime operator-() const {SimTime x; x.t = -t; return x;}

    friend const SimTime operator+(const SimTime& x, const SimTime& y);
    friend const SimTime operator-(const SimTime& x, const SimTime& y);

    friend const SimTime operator*(const SimTime& x, double d);
    friend const SimTime operator*(double d, const SimTime& x);
    friend const SimTime operator/(const SimTime& x, double d);
    friend double operator/(double d, const SimTime& x);
    friend double operator/(const SimTime& x, const SimTime& y);

    friend const SimTime operator*(const SimTime& x, const cPar& p);
    friend const SimTime operator*(const cPar& p, const SimTime& x);
    friend const SimTime operator/(const SimTime& x, const cPar& p);

    double dbl() const  {return t*invfscale;}

    int64 inUnit(int exponent) const;

    SimTime trunc(int exponent) const  {return SimTime(inUnit(exponent), exponent);}

    SimTime remainderForUnit(int exponent) const  {return (*this) - trunc(exponent);}

    void split(int exponent, int64& outValue, SimTime& outRemainder) const;

    std::string str() const;

    char *str(char *buf) const {char *endp; return SimTime::ttoa(buf, t, getScaleExp(), endp);}

    int64 raw() const  {return t;}

    const SimTime& setRaw(int64 l) {t = l; return *this;}

    static const SimTime getMaxTime() {return SimTime().setRaw(INT64_MAX);}

    static int64 getScale()  {return dscale;}

    static int getScaleExp() {return scaleexp;}

    static void setScaleExp(int e);

    static const SimTime parse(const char *s);

    static const SimTime parse(const char *s, const char *&endp);

    static char *ttoa(char *buf, int64 t, int scaleexp, char *&endp);
};

/*
 for *= and /=, we might need the following code:
    // linux bug workaround; don't change next two lines
    volatile double tmp = uint64_to_double( m_value ) * d;
    m_value = static_cast<int64>( tmp );
    return *this;
*/

inline const SimTime operator+(const SimTime& x, const SimTime& y)
{
    return SimTime(x)+=y;
}

inline const SimTime operator-(const SimTime& x, const SimTime& y)
{
    return SimTime(x)-=y;
}

inline const SimTime operator*(const SimTime& x, double d)
{
    return SimTime(x)*=d;
}

inline const SimTime operator*(double d, const SimTime& x)
{
    return SimTime(x)*=d;
}

inline const SimTime operator/(const SimTime& x, double d)
{
    return SimTime(x)/=d;
}

inline double operator/(double d, const SimTime& x)
{
    return d / x.dbl();
}

inline double operator/(const SimTime& x, const SimTime& y)
{
    return (double)x.raw() / (double)y.raw();
}

inline std::ostream& operator<<(std::ostream& os, const SimTime& x)
{
    char buf[64]; char *endp;
    return os << SimTime::ttoa(buf, x.raw(), SimTime::getScaleExp(), endp);
}

NAMESPACE_END

// used locally; needed because sign of a%b is implementation dependent if a<0
inline int64 _i64mod(const int64& any_t, const int64& positive_u)
{
    int64 m = any_t % positive_u;
    return m>=0 ? m : m+positive_u;
}

inline const OPP::SimTime floor(const OPP::SimTime& x)
{
    int64 u = OPP::SimTime::getScale();
    int64 t = x.raw();
    return OPP::SimTime().setRaw(t - _i64mod(t,u));
}

inline const OPP::SimTime floor(const OPP::SimTime& x, const OPP::SimTime& unit, const OPP::SimTime& offset = OPP::SimTime())
{
    int64 off = offset.raw();
    int64 u = unit.raw();
    int64 t = x.raw() - off;
    return OPP::SimTime().setRaw(t - _i64mod(t,u) + off);
}

inline const OPP::SimTime ceil(const OPP::SimTime& x)
{
    int64 u = OPP::SimTime::getScale();
    int64 t = x.raw() + u-1;
    return OPP::SimTime().setRaw(t - _i64mod(t,u));
}

inline const OPP::SimTime ceil(const OPP::SimTime& x, const OPP::SimTime& unit, const OPP::SimTime& offset = OPP::SimTime())
{
    int64 off = offset.raw();
    int64 u = unit.raw();
    int64 t = x.raw() - off + u-1;
    return OPP::SimTime().setRaw(t - _i64mod(t,u) + off);
}

inline const OPP::SimTime fabs(const OPP::SimTime& x)
{
    return x.raw()<0 ? OPP::SimTime().setRaw(-x.raw()) : x;
}

inline const OPP::SimTime fmod(const OPP::SimTime& x, const OPP::SimTime& y)
{
    return OPP::SimTime().setRaw(x.raw() % y.raw());
}

#endif