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>

DEFINE_SPTR(CORE_Time);
DEFINE_SVPTR(CORE_Time);

class CORE_Time : public  CORE_Object {
    SP_OBJECT(CORE_Time);

    // attributes
public:
    static const tTime MAX_YEAR;
private:
    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,...[
    int mYear;
    // month of the date [0,11]
    int mMonth;
    // week of the day in year [1,53]
    int mWeek;
    // week of the day in week  [0,6] 0:Sunday
    int mWeekDay;
    // day number [1,31]
    int mDay;
    // hours [0,23]
    int mHours;
    // minutes [0,59]
    int mMinutes;
    // seconds [0,59]
    int mSeconds;
    // milli seconds [0,999]
    unsigned long long int mMilliSeconds;
    // cpu time
    unsigned long long int mCPUTime;
    // secunds since 1900
    tTime mSecondsSince1900;
    std::clock_t mStartClock;
    tBoolean mIsChronoStarting;

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 int& year,
                                    const int& month,
                                    const int& 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 long int getTime(){
        return getDateInMilliSeconds();
    }
    inline unsigned long long int getCPUTime() const{
        return mCPUTime;
    };
    
  
    int getWeekYear(int& year) const{
        year=mYear;
        if ((mMonth==0) && (mWeek>25)) year--;
        if ((mMonth==11) && (mWeek<25)) year++;
        return mWeek;
    };

    inline int getYear() const{
        return mYear;
    };
    inline int getMonth() const{
        return mMonth+1;
    };
    inline int 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 int getDay() const{
        return mDay;
    };
    static tString getWeekIntervalString(const int& year,const int& week);
    inline tString getWeekIntervalString() {
        return getWeekIntervalString(mYear,mWeek);
    } 
    void setToFirstWeekDay(const int& year,const int& week);

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

    inline int getWeekDay() const{
        return mWeekDay;
    }; 
    inline int getMinutes() const{
        return mMinutes;
    };
    inline int getSeconds() const{
        return mSeconds;
    }; 
    inline int getHours() const{
        return mHours;
    };
    inline unsigned long long int getMilliSeconds() const{
        return mMilliSeconds;
    };
    inline tTime getSecondsSince1900() const {
        return mSecondsSince1900;
    };

    void setDate(const tTime& seconds);


    void setDate(const int& year,const int& month,const int& day,
                 const int& hour,const int& minutes,const int& seconds,const int& ms);
    inline void setDate(const int& year,const int& month,const int& day,
                        const int& hour,const int& minutes,const int& seconds) {
        setDate(year,month,day,hour,minutes,seconds,0);
    };
    inline void setDate(int year,
                        int month,
                        int 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 int& hour,const int& minutes,const int& seconds);
    void setTime(const tString& date);

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

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

    inline void setToNextDay() {
        setDate(mSecondsSince1900+24*3600);
    }; 
    inline void setToPreviousDay() {
        setDate(mSecondsSince1900-24*3600);
    };
    inline void setToPreviousDays(const int& nDays) {
        setDate(mSecondsSince1900-nDays*24*3600);
    }; 
    inline void setToNextMonth() {
        int mo=mMonth+1;
        int y=mYear;
        if (mo==12) {
            mo=0;
            y++;
        }
        setDate(y,mo+1,mDay,mHours,mMinutes,mSeconds,0);
    };  
    inline void setToPreviousMonth() {
        int mo=mMonth-1;
        int 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 int& year,const int& month) {
        int mo=month+1;
        int ye=year;
        if (mo==13) {
            mo=1;
            ye++;
        }
        setDate(ye,mo,1,0,0,0,0);
        setDate(mSecondsSince1900-23*3600);
    };

    inline void startChrono() {
        mIsChronoStarting=true;
        mStartClock=std::clock();
    }
    inline unsigned long long int  continueChrono() {
        if (!mIsChronoStarting) throw CORE_Exception("common/core/",
                                                     "CORE_Time::stop()",
                                                     "can not continue a chrono without starting it");
        std::clock_t t=std::clock();
        unsigned long long int dt=(unsigned long long int) (1000.0*(t-mStartClock)/CLOCKS_PER_SEC);
        mStartClock=t;
        return dt;
    }
    
    inline unsigned long long int  stopChrono() {
        if (!mIsChronoStarting) throw CORE_Exception("common/core/",
                                                     "CORE_Time::stop()",
                                                     "can not stop a chrono without starting it");
        mIsChronoStarting=false;
        return (unsigned long long int) (1000.0*(std::clock()-mStartClock)/CLOCKS_PER_SEC);
    }
    
    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 long int& duration,
                               int& days,
                               int& hours,
                               int& minutes,
                               int& seconds,
                               int& ms);
    inline static tString getDuration(const long int& duration) {
    
        int days;
        int hours;
        int minutes;
        int seconds;
        int 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);
  
};

#endif // end of ifndef