CORE_Time.h

Go to the documentation of this file.

#ifndef CORE_TIME_H
#define CORE_TIME_H

#include "CORE_Object.h"
#include "CORE_Pointers.h"
#include "CORE_ListPointers.h"
#include "types.h"
#include <ctime>
#include <chrono>



DEFINE_SPTR(CORE_Time);
DEFINE_SVPTR(CORE_Time);

class CORE_Time : public  CORE_Object {
    SP_OBJECT(CORE_Time);

    // attributes
public:
    static const tULLInt MAX_YEAR;

    static const tFlag SYSTEM_CLOCK_TIME=0;
    static const tFlag HR_CLOCK_TIME=1;
    static const tFlag CLOCK_TIME=2;
    
private:
    static tFlag TIME_TYPE;
    
    static const tFlag YEAR;
    static const tFlag MONTH;
    static const tFlag WEEK;
    static const tFlag DAY;
    static const tFlag WEEK_DAY;
    static const tFlag HOUR;
    static const tFlag MINUTE;
    static const tFlag SECUND;
    static const tFlag MILLI_SECUNDS;
  
    // year of the date [1900,...[
    tUInteger mYear;
    // month of the date [0,11]
    tUInteger mMonth;
    // week of the day in year [1,53]
    tUInteger mWeek;
    // week of the day in week  [0,6] 0:Sunday
    tUInteger mWeekDay;
    // day number [1,31]
    tUInteger mDay;
    // hours [0,23]
    tUInteger mHours;
    // minutes [0,59]
    tUInteger mMinutes;
    // seconds [0,59]
    tUInteger mSeconds;
    // milli seconds [0,999]
    tULLInt mMilliSeconds;
    // cpu time
    tULLInt mCPUTime;
    // secunds since 1900
    tTime mSecondsSince1900;

    //chrono
    std::chrono::high_resolution_clock::time_point   mStartHRClock;
    std::chrono::system_clock::time_point   mStartSystemClock;
    tULLInt mStartClock;
    
    
    tBoolean mIsHRClockChronoStarting;
    tBoolean mIsSystemClockChronoStarting;
    tBoolean mIsClockChronoStarting;

public:
    static const tString DAYS[]; 
    static const tString JOURS[];
    // month names
    static const tString MONTHS[];
    static const tString MOIS[];


    // asociations
    // methods
  
public:
    // builders
    CORE_Time();
  
  
    virtual ~CORE_Time();

  
public:
    inline static SP::CORE_Time New(){
        SP::CORE_Time p(new CORE_Time(),CORE_Time::Delete());
        return p;
    }; 
    inline static SP::CORE_Time New(const CORE_Time& time){
        SP::CORE_Time p=New();
        p->setDate(time);
        return p;
    };  
    inline static SP::CORE_Time New(const CORE_Time* time){
        SP::CORE_Time p=New();
        if (time!=null) p->setDate(*time);
        return p;
    }; 
    inline static SP::CORE_Time New(const tTime& time){
        SP::CORE_Time p=New();
        p->setDate(time);
        return p;
    }; 
    inline static SP::CORE_Time New(const SP::CORE_Time& time){
        SP::CORE_Time p=New();
        p->setDate(time.get());
        return p;
    }; 

    inline static SP::CORE_Time New(const tUInteger& year,
                                    const tUInteger& month,
                                    const tUInteger& day){
        SP::CORE_Time t(new CORE_Time(),CORE_Time::Delete());
        t->setDate(year,month,day,0,0,1,0);
        return t;
    };
 
 
    static tTime getDateInSeconds(){
        SP::CORE_Time time=CORE_Time::New();
        tTime secs=time->getSecondsSince1900();
        return secs;
    }
    static tTime getDateInMilliSeconds(){
        SP::CORE_Time time=CORE_Time::New();
        tTime secs=time->getSecondsSince1900()*1000+time->getMilliSeconds();
        return secs;
    }
    
    static tULLInt getTime(){
        return getDateInMilliSeconds();
    }
    inline tULLInt getCPUTime() const{
        return mCPUTime;
    };
    
  
    tUInteger getWeekYear(tUInteger& year) const{
        year=mYear;
        if ((mMonth==0) && (mWeek>25)) year--;
        if ((mMonth==11) && (mWeek<25)) year++;
        return mWeek;
    };

    inline const tUInteger& getYear() const{
        return mYear;
    };
    inline tUInteger getMonth() const{
        return mMonth+1;
    };
    inline tUInteger getDaysNumberInMonth() const {
        SP::CORE_Time t;
        switch(mMonth) {
        case 0:
        case 2:
        case 4:
        case 6:
        case 7:
        case 9:
        case 11:
            return 31;
        case 1:
            t=CORE_Time::New();
            t->setDate(mYear,mMonth+1,29,0,0,0,0);
            if (t->getMonth()==2) return 29;
            return 28;
        case 3:
        case 5:
        case 8:
        case 10:
            return 30;
        }
        return 30;
    }
    inline tUInteger getDay() const{
        return mDay;
    };
    static tString getWeekIntervalString(const tUInteger& year,const tUInteger& week);
    
    inline tString getWeekIntervalString() {
        return getWeekIntervalString(mYear,mWeek);
    } 
    void setToFirstWeekDay(const tUInteger& year,const tUInteger& week);

    void setToWeekDay(const tUInteger& year,const tUInteger& week,const tUInteger& day);
 

    inline const tUInteger& getWeekDay() const{
        return mWeekDay;
    }; 
    inline const tUInteger& getMinutes() const{
        return mMinutes;
    };
    inline const tUInteger& getSeconds() const{
        return mSeconds;
    }; 
    inline const tUInteger& getHours() const{
        return mHours;
    };
    inline const tULLInt& getMilliSeconds() const{
        return mMilliSeconds;
    };
    inline const tTime& getSecondsSince1900() const {
        return mSecondsSince1900;
    };

    void setDate(const tTime& seconds);


    void setDate(const tUInteger& year,const tUInteger& month,const tUInteger& day,
                 const tUInteger& hour,const tUInteger& minutes,const tUInteger& seconds,const tUInteger& ms);
    inline void setDate(const tUInteger& year,const tUInteger& month,const tUInteger& day,
                        const tUInteger& hour,const tUInteger& minutes,const tUInteger& seconds) {
        setDate(year,month,day,hour,minutes,seconds,0);
    };
    inline void setDate(tUInteger year,
                        tUInteger month,
                        tUInteger day){
        setDate(year,month,day,0,0,0);
    };
  
    void setDate(const tString& date); 
    inline void setDate(const CORE_Time& time) {
        setDate(time.getYear(),
                time.getMonth(),
                time.getDay(),
                time.getHours(),
                time.getMinutes(),
                time.getSeconds());
    
    }; 
    inline void setDate(SP::CORE_Time time) {
        setDate(time.get());
    }; 
    inline void setDate(const CORE_Time* time) {
        if (time==null) return;
        setDate(time->getYear(),
                time->getMonth(),
                time->getDay(),
                time->getHours(),
                time->getMinutes(),
                time->getSeconds());
    
    };

    void setDate(const tString& date,const tString& format);  

    void setHour(const tString& h);
    
    void setTime(const tUInteger& hour,const tUInteger& minutes,const tUInteger& seconds);
    void setTime(const tString& date);

    static tLLInt subTimes(const CORE_Time& time1, const CORE_Time& time2);
    static tLLInt subTimes(const SP::CORE_Time& time1, 
                           const SP::CORE_Time& time2); 
    tLLInt sub(const CORE_Time& time) const; 
    tLLInt sub(const SP::CORE_Time& time) const {
        return sub(time.get());
    }
    
    tLLInt sub(const CORE_Time* time) const {
        if (time!=null) return sub(*time);
        return getSecondsSince1900();
    }  

    static tLLInt subTimesInMilliSeconds(const CORE_Time& time1, const CORE_Time& time2);

    static tLLInt subTimesInMilliSeconds(const SP::CORE_Time& time1, 
                                         const SP::CORE_Time& time2);
    
    tLLInt subInMilliSeconds(const CORE_Time& time) const;
    
    tLLInt subInMilliSeconds(const SP::CORE_Time& time) const {
        return sub(time.get());
    } 
    tLLInt subInMilliSeconds(const CORE_Time* time) const {
        if (time!=null) return sub(*time);
        return getSecondsSince1900()*1000+mMilliSeconds;
    }

    inline void setToNextDay() {
        setDate(mSecondsSince1900+24*3600);
    }; 
    inline void setToPreviousDay() {
        setDate(mSecondsSince1900-24*3600);
    };
    inline void setToPreviousDays(const tUInteger& nDays) {
        setDate(mSecondsSince1900-nDays*24*3600);
    }; 
    inline void setToNextMonth() {
        tUInteger mo=mMonth+1;
        tUInteger y=mYear;
        if (mo==12) {
            mo=0;
            y++;
        }
        setDate(y,mo+1,mDay,mHours,mMinutes,mSeconds,0);
    };  
    inline void setToPreviousMonth() {
        tInteger mo=mMonth-1;
        tUInteger y=mYear;
        if (mo==-1) {
            mo=11;
            y--;
        }
        setDate(y,mo+1,mDay,mHours,mMinutes,mSeconds,0);
    }; 
    inline void setToNextWeek() {
        setDate(mSecondsSince1900+7*24*3600);
    };
    inline void setToPreviousWeek() {
        setDate(mSecondsSince1900-7*24*3600);
    }; 
    inline void setToLastDay(const tUInteger& year,const tUInteger& month) {
        tUInteger mo=month+1;
        tUInteger ye=year;
        if (mo==13) {
            mo=1;
            ye++;
        }
        setDate(ye,mo,1,0,0,0,0);
        setDate(mSecondsSince1900-23*3600);
    };

    inline void setTimeType(const tFlag & f) {
        TIME_TYPE=f;
    }
    
    /* \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;
    }

     
    /* \brief start the chrono time
     */
    inline void startChronoTime()  {
        startChronoTime(TIME_TYPE);
    }
    
    /* \brief start the chrono time
     * @param[in] f : type of the time in {CHRONO_TIME, CLOCK_TIME }
     */
    inline void startChronoTime(const tFlag& f)  {
      
        switch(f) {
        case HR_CLOCK_TIME:
            mStartHRClock=std::chrono::high_resolution_clock::now();
            mIsHRClockChronoStarting=true;
            break;
        case SYSTEM_CLOCK_TIME:
            mStartSystemClock=std::chrono::system_clock::now();
            mIsSystemClockChronoStarting=true;
            break;
        case CLOCK_TIME:
        default:
            mStartClock=std::clock();
            mIsClockChronoStarting=true;
            break;
        }
    }
    inline tULLInt stopChronoTime() {
        return stopChronoTime(TIME_TYPE);
    }
    
    /* \brief start the chrono time
     * @param[in] f : type of the time in {CHRONO_TIME, CLOCK_TIME }
     * @return the duration of the chrono in milliseconds
     */
    inline tULLInt stopChronoTime(const tFlag& f)  {
        
        tULLInt nMilliSeconds=0;
        switch(f) {
        case HR_CLOCK_TIME:
            if (!mIsHRClockChronoStarting) throw CORE_Exception("common/core/",
                                                                "CORE_Time::stopChronoTime()",
                                                                "can not stop a HR clock chrono without starting it");
            
            nMilliSeconds=(tULLInt) std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()-mStartHRClock).count();
            mIsHRClockChronoStarting=false;
            break;
        case SYSTEM_CLOCK_TIME:
            if (!mIsSystemClockChronoStarting) throw CORE_Exception("common/core/",
                                                                "CORE_Time::stopChronoTime()",
                                                                "can not stop a system clock chrono without starting it");
            nMilliSeconds=(tULLInt) std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-mStartSystemClock).count();
            mIsSystemClockChronoStarting=false;
            break;
        case CLOCK_TIME:
        default:
            if (!mIsClockChronoStarting) throw CORE_Exception("common/core/",
                                                              "CORE_Time::stopChronoTime()",
                                                              "can not stop a  clock chrono without starting it");
            nMilliSeconds=getClockDuration(mStartClock);
            mIsClockChronoStarting=false;
            break;
        }
        return nMilliSeconds;
    }
    
  
   
    inline tULInt continueChronoTime() {
        return continueChronoTime(TIME_TYPE);
        
    }
     /* \brief start the chrono time
     * @param[in] f : type of the time in {CHRONO_TIME, CLOCK_TIME }
     * @return the duration of the chrono in seconds
     */
    inline tULLInt continueChronoTime(const tFlag& f)  {
        tULLInt dt=stopChronoTime(f);
        startChronoTime(f);
        return dt;
    }
    
  
   
    
    inline tBoolean isEqual(const CORE_Time* t) const {
        if (t==null) return false;
        return (mSecondsSince1900==t->getSecondsSince1900());
    }; 
    inline tBoolean isEqual(const CORE_Time& t) const {
        return (mSecondsSince1900==t.getSecondsSince1900());
    }; 
    inline tBoolean isBefore(const CORE_Time& t) const {
        return (mSecondsSince1900<t.getSecondsSince1900());
    }; 
    inline tBoolean isBefore(const CORE_Time* t) const {
        if (t==null) return true;
        return (mSecondsSince1900<t->getSecondsSince1900());
    }; 
    inline tBoolean isAfter(const CORE_Time& t) const {
        return (mSecondsSince1900>t.getSecondsSince1900());
    };  
    inline tBoolean isAfter(const CORE_Time* t) const {
        if (t!=null)
            return (mSecondsSince1900>t->getSecondsSince1900());
        return false;
    }; 
    inline tBoolean isBeforeOrEqual(const CORE_Time& t) const {
        return (mSecondsSince1900<=t.getSecondsSince1900());
    }; 
    inline tBoolean isAfterOrEqual(const CORE_Time& t) const {
        return (mSecondsSince1900>=t.getSecondsSince1900());
    };
    inline tBoolean isEqual(const SP::CORE_Time& t) const {
        return (mSecondsSince1900==t->getSecondsSince1900());
    }; 
    inline tBoolean isBefore(const SP::CORE_Time& t) const {
        return (mSecondsSince1900<t->getSecondsSince1900());
    }; 
    inline tBoolean isAfter(const SP::CORE_Time& t) const {
        return (mSecondsSince1900>t->getSecondsSince1900());
    }; 
    inline tBoolean isBeforeOrEqual(const SP::CORE_Time& t) const {
        return (mSecondsSince1900<=t->getSecondsSince1900());
    }; 
    inline tBoolean isAfterOrEqual(const SP::CORE_Time& t) const {
        return (mSecondsSince1900>=t->getSecondsSince1900());
    };

    static tString getDuration(const tULLInt& duration,
                               tUInteger& days,
                               tUInteger& hours,
                               tUInteger& minutes,
                               tUInteger& seconds,
                               tUInteger& ms);
    inline static tString getDuration(const tULLInt& duration) {
    
        tUInteger days;
        tUInteger hours;
        tUInteger minutes;
        tUInteger seconds;
        tUInteger ms;
        return getDuration(duration,days,hours,minutes,seconds,ms);
    }
        

    virtual tString toString() const; 
    tString toString(const tString& format) const;


private:
    static char *_fmt(const struct tm *t, char *pt, const char *ptlim);
    static char *_conv(const int n, const char *format, char *pt, const char *ptlim);
    static char *_add(const char *str, char *pt, const char *ptlim);
  
    static int getWeek(const struct tm *t);
    static tUInteger modZ(const tInteger& a,const tInteger& b)  {
        return (a>=0) ? a%b : a%b+b;
    }
    
  
};

#endif // end of ifndef