CORE_Chrono.h

Go to the documentation of this file.

#ifndef CORE_Chrono_H
#define CORE_Chrono_H
 
//inherits class header
#include "CORE_Object.h"
  
//include the chrono header
#include <chrono>
//C time header
#include <ctime>
 
class CORE_Chrono : public  CORE_Object {
    // ATTRIBUTES
 
    public:
  
    
private:
    // ASSOCIATION
    //timer
    std::chrono::high_resolution_clock mTimer;
    //current time
    std::chrono::time_point<std::chrono::high_resolution_clock> 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() {
        auto 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=mTimer.now();
    }
    inline  std::chrono::duration<tReal> stop() {
        auto end=mTimer.now();
        std::chrono::duration<tReal>  duration= end-mStart;
        mStart=end;
        return duration;
    }
 
    /* \brief get the clock time
     * @return the time
     */
    inline static tULLInt GetClockTime()  {
        return std::clock();
    }
    /* \brief get the clock time duration
     * @param[in] start_time : start time in clock
     * @return the duration in milliseconds
     */
    inline static tULLInt GetClockDuration(const tULLInt& startTime)  {
        return (1000*(std::clock()-startTime))/CLOCKS_PER_SEC;
    }
    static inline tULLInt ConvertDuration(std::chrono::duration<tReal>&& duration) {
        return std::chrono::duration_cast< std::chrono::milliseconds >( duration ).count();
    }
    static inline tULLInt ConvertDuration(const std::chrono::duration<tReal>& duration) {
        return std::chrono::duration_cast< std::chrono::milliseconds >( duration ).count();
    }
    
    static tReal ConvertDuration(std::chrono::duration<tReal>&& duration,
                                 tUInt& d,
                                 tUInt& h,
                                 tUInt& m,
                                 tUInt& s,
                                 tUInt& ms,
                                 tUInt& mus,
                                 tUInt& ns) {
        
        tReal ret=duration.count();
        
        auto hours = std::chrono::duration_cast< std::chrono::hours >( duration );
        h=hours.count();
        d=h/24;
        h=h%24;
        duration -= hours;
        
        auto minutes = std::chrono::duration_cast< std::chrono::minutes >( duration );
        m=minutes.count();
        duration -= minutes;
        
        auto seconds = std::chrono::duration_cast< std::chrono::seconds >( duration );
        s=seconds.count();
        duration -= seconds;
        
        auto milliseconds = std::chrono::duration_cast< std::chrono::milliseconds >( duration );
        ms=milliseconds.count();
        duration -= milliseconds;
        
        auto microseconds = std::chrono::duration_cast< std::chrono::microseconds >( duration );
        mus=microseconds.count();
        duration -= microseconds;
        
        auto nanoseconds = std::chrono::duration_cast< std::chrono::nanoseconds >( duration );
        ns=nanoseconds.count();
 
        return ret;
    }
        
    static tReal ConvertDuration(std::chrono::duration<tReal>& duration,
                                 tUInt& d,
                                 tUInt& h,
                                 tUInt& m,
                                 tUInt& s,
                                 tUInt& ms,
                                 tUInt& mus,
                                 tUInt& ns) {
       
        
        
        tReal ret=duration.count();
        
        auto hours = std::chrono::duration_cast< std::chrono::hours >( duration );
        h=hours.count();
        d=h/24;
        h=h%24;
        duration -= hours;
        
        auto minutes = std::chrono::duration_cast< std::chrono::minutes >( duration );
        m=minutes.count();
        duration -= minutes;
        
        auto seconds = std::chrono::duration_cast< std::chrono::seconds >( duration );
        s=seconds.count();
        duration -= seconds;
        
        auto milliseconds = std::chrono::duration_cast< std::chrono::milliseconds >( duration );
        ms=milliseconds.count();
        duration -= milliseconds;
        
        auto microseconds = std::chrono::duration_cast< std::chrono::microseconds >( duration );
        mus=microseconds.count();
        duration -= microseconds;
        
        auto nanoseconds = std::chrono::duration_cast< std::chrono::nanoseconds >( duration );
        ns=nanoseconds.count();
 
        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