CORE_Chrono.h

#ifndef CORE_Chrono_H
#define CORE_Chrono_H
 
//inherits class header
#include "CORE_Object.h"
  
 
class CORE_Chrono : public  CORE_Object {
    // ATTRIBUTES
 
    public:
  
    
private:
    // ASSOCIATION
    //current time
    tWallTime  mStart;
 
    tUInt mYear;//in [1900, ...[
    tCInt mMonth;//in [0,11]
    tUCInt mDay;//day in [1,31]
    tUCInt mWeekDay;//day in [0,6]
    tUCInt mHour;//in [0,23]
    tUCInt mMinute;//in [0,59]
    tUCInt mSecond;//in [0,59]
    
    // METHODS
  
  
public:
    // CONSTRUCTORS
    CORE_Chrono() {
        tWallTime now=std::chrono::system_clock::now();
        time_t tnow = std::chrono::system_clock::to_time_t(now);
        
        tm* ptm = localtime(&tnow);
        mYear= ptm->tm_year + 1900;
        mMonth = ptm->tm_mon ;
        mDay= ptm->tm_mday;
        mHour = ptm->tm_hour;
        mMinute = ptm->tm_min;
        mSecond= ptm->tm_sec;
        mWeekDay=ptm->tm_wday;
   
    
    }
   
  
  
  
    // DESTRUCTORS
    virtual ~CORE_Chrono(void) {
    }
  
  
public:
 
 
private:
  
   
public:
   
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
 
public:
    inline void start() {
        mStart=std::chrono::high_resolution_clock::now();
    }
    inline  tULLInt stop() {
        tWallTime end=std::chrono::high_resolution_clock::now();
        std::chrono::duration<tReal,std::milli> duration=(end-mStart);
        mStart=end;
        return (tULLInt) duration.count();
    }
 
    inline static tULLInt GetClockTime()  {
        return std::clock();
    }
    inline static tULLInt GetClockDuration(const tULLInt& startTime)  {
        return (1000*(std::clock()-startTime))/CLOCKS_PER_SEC;
    }
   
    inline static  tULLInt ConvertDuration(tULLInt duration,
                                           tUInt& d,
                                           tUInt& h,
                                           tUInt& m,
                                           tUInt& s,
                                           tUInt& ms) {
        
        tULLInt w=duration;
        
        //duration=ms+1000*(s+60*(m+60*(h+24*d)))
        ms=duration%1000;
        duration/=1000;
        s=duration%60;
        duration/=60;
        m=duration%60;
        duration/=60;
        h=duration%24;
        duration/=24;
        d=duration;
        return w;
    }
    inline static  tString ConvertDurationToString(tULLInt duration) {
        
        tString ret;
        ret.reserve(30);
        //duration=ms+1000*(s+60*(m+60*(h+24*d)))
        ret+=std::to_string((duration%1000))+"ms ";
        duration/=1000;
        
        ret.insert(0,std::to_string((duration%60))+"s ");
        duration/=60;
 
        ret.insert(0,std::to_string((duration%60))+"m ");
        duration/=60;
        
        ret.insert(0,std::to_string((duration%24))+"h ");
        duration/=24;
 
        ret.insert(0,std::to_string((duration))+"d ");
        return ret;
    }
        
    inline tString getDate() {
        std::stringstream cstr;
        
        cstr<<mYear<<"/";
        if (mMonth<9) cstr<<"0";
        cstr<<((int)mMonth+1)<<"-";
        if (mDay<10) cstr<<"0";
        cstr<<((int)mDay);
        cstr<<"/";
        if (mHour<10) cstr<<"0";
        cstr<<((int)mHour)<<":";
        if (mMinute<10) cstr<<"0";
        cstr<<((int)mMinute)<<":";
        if (mSecond<10) cstr<<"0";
        cstr<<((int)mSecond);
        return cstr.str();
    }
 
    inline static tString GetDate() {
        CORE_Chrono time;
        return time.getDate();
    }
 
private:
 
   
};
 
#endif