simtime.h

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

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

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

#ifndef __OMNETPP_SIMTIME_H
#define __OMNETPP_SIMTIME_H

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

namespace omnetpp {

class cPar;

// the most positive int64_t 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,
    SIMTIME_AS = -18
};

class SIM_API SimTime
{
  private:
    int64_t t;

    static int scaleexp;     // scale exponent in the range -18..0
    static int64_t 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
    static int64_t maxseconds; // the largest number in seconds that can be represented with this scaleexp
    static bool checkmul;    // when true, multiplications are checked for integer overflow

    static const int SCALEEXP_UNINITIALIZED = 0xffff;

  public:
    static const SimTime ZERO;

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

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

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

    int64_t toInt64(double i64) {
#ifndef USE_OMNETPP4x_FINGERPRINTS
         i64 = floor(i64 + 0.5);
#endif
         if (fabs(i64) > INT64_MAX_DBL)
             rangeErrorInt64(i64);
         return (int64_t)i64;
    }

    void setSeconds(int64_t sec) {
        if (sec > maxseconds)
            rangeErrorSeconds(sec);
        t = dscale * sec;
    }

    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 checkedMul(int64_t x);
    void rangeErrorInt64(double i64);
    void rangeErrorSeconds(int64_t x);
    void overflowAdding(const SimTime& x);
    void overflowSubtracting(const SimTime& x);
    void overflowNegating();

  public:
    // internal: Formats a time string. Use SIMTIME_MS etc constants for prec. Note: it performs TRUNCATION towards zero, not rounding!
    std::string format(int prec=getScaleExp(), const char *decimalSep=".", const char *digitSep="", bool addUnits=false, const char *beforeUnit=nullptr, const char *afterUnit=nullptr) const;

  public:
    SimTime() {t=0;}

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

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

    SimTime(int64_t value, SimTimeUnit unit);

    SimTime(const SimTime& x) {t=x.t;}

    const SimTime& operator=(const SimTime& x) {t=x.t; return *this;}
    const SimTime& operator=(const cPar& d);
    const SimTime& operator=(double d) {assertInited(d); t=toInt64(fscale*d); return *this;}
    const SimTime& operator=(short d) {assertInited(d); setSeconds(d); return *this;}  //TODO check overflow
    const SimTime& operator=(int d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(long d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(long long d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(unsigned short d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(unsigned int d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(unsigned long d) {assertInited(d); setSeconds(d); return *this;}
    const SimTime& operator=(unsigned long long d) {assertInited(d); setSeconds(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; if (x.t==INT64_MIN) x.overflowNegating(); return x;}

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

    const SimTime& operator*=(double d) {t=toInt64(t*d); return *this;}
    const SimTime& operator*=(short d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(int d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(long d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(long long d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(unsigned short d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(unsigned int d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(unsigned long d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(unsigned long long d) {if (checkmul) checkedMul(d); else t*=d; return *this;}
    const SimTime& operator*=(const cPar& p);

    const SimTime& operator/=(double d) {t=toInt64(t/d); return *this;}
    const SimTime& operator/=(short d) {t/=d; return *this;}
    const SimTime& operator/=(int d) {t/=d; return *this;}
    const SimTime& operator/=(long d) {t/=d; return *this;}
    const SimTime& operator/=(long long d) {t/=d; return *this;}
    const SimTime& operator/=(unsigned short d) {t/=d; return *this;}
    const SimTime& operator/=(unsigned int d) {t/=d; return *this;}
    const SimTime& operator/=(unsigned long d) {t/=d; return *this;}
    const SimTime& operator/=(unsigned long long d) {t/=d; return *this;}
    const SimTime& operator/=(const cPar& p);

    friend const SimTime operator*(const SimTime& x, double d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, short d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, int d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, long d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, long long d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, unsigned short d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, unsigned int d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, unsigned long d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, unsigned long long d) { return SimTime(x)*=d; }
    friend const SimTime operator*(const SimTime& x, const cPar& p) { return SimTime(x)*=p; }

    friend const SimTime operator*(double d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(short d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(int d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(long d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(long long d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(unsigned short d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(unsigned int d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(unsigned long d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(unsigned long long d, const SimTime& x) { return SimTime(x)*=d; }
    friend const SimTime operator*(const cPar& p, const SimTime& x) { return SimTime(x)*=p; }

    friend const SimTime operator/(const SimTime& x, double d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, short d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, int d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, long d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, long long d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, unsigned short d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, unsigned int d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, unsigned long d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, unsigned long long d) { return SimTime(x)/=d; }
    friend const SimTime operator/(const SimTime& x, const cPar& p) { return SimTime(x)/=p; }

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

    friend double operator/(double x, const SimTime& y) { return x / y.dbl(); }
    friend double operator/(short x, const SimTime& y) { return (long long)x / y; }
    friend double operator/(int x, const SimTime& y) { return (long long)x / y; }
    friend double operator/(long x, const SimTime& y) { return (long long)x / y; }
    friend double operator/(long long x, const SimTime& y);
    friend double operator/(unsigned short x, const SimTime& y) { return (unsigned long long)x / y; }
    friend double operator/(unsigned int x, const SimTime& y) { return (unsigned long long)x / y; }
    friend double operator/(unsigned long x, const SimTime& y) { return (unsigned long long)x / y; }
    friend double operator/(unsigned long long x, const SimTime& y);
    friend double operator/(const cPar& p, const SimTime& x);


    bool isZero() const {return t==0;}

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

    int64_t inUnit(SimTimeUnit unit) const;

    SimTime trunc(SimTimeUnit unit) const  {return SimTime(inUnit(unit), unit);}

    SimTime remainderForUnit(SimTimeUnit unit) const  {return (*this) - trunc(unit);}

    void split(SimTimeUnit unit, int64_t& outValue, SimTime& outRemainder) const;

    std::string str() const {char buf[64]; return str(buf);}

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

    std::string ustr() const;

    std::string ustr(SimTimeUnit unit) const;

    int64_t raw() const  {return t;}

    static SimTime fromRaw(int64_t l) {SimTime tmp; tmp.t = l; return tmp;}

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

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

    static int64_t 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 t, int scaleexp, char *&endp);
};

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 omnetpp

#endif