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"

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]
  int mMilliSeconds;
  // cpu time
  long int mCPUTime;
  // secunds since 1900
  tTime mSecondsSince1900;

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


  // asociations
  // methods
  
 protected:
  // 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 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 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 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