Time.h

#pragma once


#include <libutl/Duration.h>


UTL_NS_BEGIN;


enum tm_day_t
{
    tm_sunday,    
    tm_monday,    
    tm_tuesday,   
    tm_wednesday, 
    tm_thursday,  
    tm_friday,    
    tm_saturday   
};


enum tm_month_t
{
    tm_january,   
    tm_february,  
    tm_march,     
    tm_april,     
    tm_may,       
    tm_june,      
    tm_july,      
    tm_august,    
    tm_september, 
    tm_october,   
    tm_november,  
    tm_december   
};


enum tm_unit_t
{
    tm_second,    
    tm_minute,    
    tm_half_hour, 
    tm_hour,      
    tm_day,       
    tm_week,      
    tm_month      
};


enum tm_dst_t
{
    tm_dst_off,  
    tm_dst_on,   
    tm_dst_auto, 
    tm_dst_leave 
};



class Time : public Object
{
    UTL_CLASS_DECL(Time, Object);

public:
    Time(const String& fmt, const String& str)
    {
        set(fmt, str);
    }

    Time(uint_t year,
         uint_t month = 1,
         uint_t day = 1,
         uint_t hour = 0,
         uint_t min = 0,
         double sec = 0,
         bool isGMT = false)
    {
        set(year, month, day, hour, min, sec, isGMT);
    }

    Time(time_t t)
    {
        set(t);
    }

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);



    operator time_t() const
    {
        return _dateTime;
    }

    time_t
    get() const
    {
        return _dateTime;
    }

    void getComponents(uint_t* year,
                       uint_t* month,
                       uint_t* day,
                       uint_t* wday = nullptr,
                       uint_t* hour = nullptr,
                       uint_t* min = nullptr,
                       double* sec = nullptr,
                       bool* isDST = nullptr,
                       bool isGMT = false) const;

    bool
    isNull() const
    {
        return (getYear() == 1970);
    }

    void
    setNull()
    {
        set((time_t)0);
    }

    uint_t
    getYear() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_year;
    }

    uint_t
    getMonth() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_mon;
    }

    uint_t
    getDay() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_mday;
    }

    uint_t
    getDayOfWeek() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_wday;
    }

    uint_t
    getHour() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_hour;
    }

    uint_t
    getMin() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_min;
    }

    uint_t
    getSec() const
    {
        struct tm* tmP = localtime(&_dateTime);
        return tmP->tm_sec;
    }

    uint_t
    getTimeOfDay() const
    {
        uint_t h, m;
        double s;
        getComponents(nullptr, nullptr, nullptr, nullptr, &h, &m, &s);
        return (h * 3600) + (m * 60) + s;
    }

    uint_t maxDay() const;

    void
    set(time_t dateTime)
    {
        _dateTime = dateTime;
    }

    void set(uint_t year,
             uint_t month,
             uint_t day,
             uint_t hour = 0,
             uint_t min = 0,
             double sec = 0,
             bool isGMT = false);

    Time&
    setCurrent()
    {
        set(time(nullptr));
        return *this;
    }



    virtual String toString() const;

    String toString(const String& fmt) const;

    String toGMTstring() const;

    String toGMTstring(const String& fmt) const;

    void set(const String& fmt, const String& str);



    Time& roundDown(uint_t unit);

    Time& roundDown(const Duration& dur);

    Time& roundUp(uint_t unit);

    Time& roundUp(const Duration& dur);



    Time& operator=(time_t t)
    {
        set(t);
        return self;
    }

    Time operator+(int i) const
    {
        return operator+(Duration(i));
    }

    Time operator+(const Duration& rhs) const
    {
        Time res = *this;
        res._dateTime += (time_t)rhs.get();
        return res;
    }

    Time operator-(const Duration& rhs) const
    {
        Time res = *this;
        res._dateTime -= (time_t)rhs.get();
        return res;
    }

    Time operator-(int i) const
    {
        return *this - Duration(i);
    }

    Duration operator-(const Time& rhs) const;

    const Time& operator+=(const Duration& rhs)
    {
        _dateTime += (time_t)rhs.get();
        return *this;
    }

    const Time& operator-=(const Duration& rhs)
    {
        _dateTime -= (time_t)rhs.get();
        return *this;
    }



    static Time
    current()
    {
        Time res;
        res.setCurrent();
        return res;
    }

    static Time today(uint_t hour = 0, uint_t min = 0, double sec = 0);

    static const char* abbrevWeekDayName[7];
    static const char* weekDayName[7];
    static const char* abbrevMonthName[12];
    static const char* monthName[12];
    static const uint_t monthDays[12];

private:
    void
    init()
    {
        setNull();
    }
    void
    deInit()
    {
    }

private:
    static int secondsFromGMT;
    time_t _dateTime;
};


UTL_CLASS_SERIALIZE(utl::Time);


UTL_NS_END;