TSATime.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/

#ifndef TSA_TIME__INCLUDED
#define TSA_TIME__INCLUDED

#include  "TSATypeDef.h"

#include <ctime>
#include <ostream>
#include <chrono>
#include <string>

namespace tsa {
    class holiday_list;
    class out_storage_stream;
    class in_storage_stream;
    class date_time;
    class variant;
    class duration;
    class string;
    class date_time;

    enum local_or_utc_time_select {
        utc_time = 0,
        local_time = 1,
    };

    enum set_timezone_offset_select {
        with_timezone_offset,
        no_timezone_offset
    };

    /*
    ** ====================================================
    ** >>>            class time_of_day                 <<<
    ** ====================================================
    */

    class time_of_day {
    private:
        int64_t m_usec_since_midnight;
    private:
        template<class Archive>
        void serialize(Archive & ar)
        {
            ar(m_usec_since_midnight);
        }
    public:
        time_of_day(void);
        time_of_day(uint32_t hour, uint32_t min, uint32_t sec = 0, uint32_t u_sec = 0);
        time_of_day(const time_of_day&);
        time_of_day(const std::string& time_str);
        ~time_of_day(void);

        uint32_t hour(void)const;
        uint32_t minute(void)const;
        uint32_t second(void)const;
        uint32_t usec(void)const;
        uint32_t microsec(void)const;
        int64_t  microsec_since_midnight(void)const;
        void microsec_since_midnight(int64_t usec_since_midnight);
        std::string to_string(const char* format = "hh:mm:ss.f")const;
        bool operator==(const time_of_day& other)const {
            return m_usec_since_midnight == other.m_usec_since_midnight;
        }
        bool operator!=(const time_of_day& other)const {
            return m_usec_since_midnight != other.m_usec_since_midnight;
        }
        bool operator<(const time_of_day& other)const {
            return m_usec_since_midnight < other.m_usec_since_midnight;
        }
        bool operator>(const time_of_day& other)const {
            return m_usec_since_midnight > other.m_usec_since_midnight;
        }
        bool operator<=(const time_of_day& other)const {
            return m_usec_since_midnight <= other.m_usec_since_midnight;
        }
        bool operator>=(const time_of_day& other)const {
            return m_usec_since_midnight >= other.m_usec_since_midnight;
        }
    };

    std::ostream& operator<<(std::ostream& stream, const time_of_day& td);


    /*
    ** ====================================================
    ** >>>                class date                    <<<
    ** ====================================================
    */

    class dll_export date {
        tsa_declare_testable;
        friend class variant;
    protected:
        int m_julian_day;
        char m_time_zone_offset_half_hours;
    public:
        template<class Archive>
        void serialize(Archive & ar)
        {
            ar(m_julian_day);
            ar(m_time_zone_offset_half_hours);
        }
    protected:
        static int ymd_to_jd(int y, int m, int d);
        static void jd_to_jmd(int jd, int& y, int& m, int& d);
        static int s_arr_days_in_month[12];
        static std::string s_months_short_names[12];
        static const std::string s_class_name;
        date& add_days(int days);
        date& subtract_days(int days);
        int Subtract(const date other) const;
        void to_year_month_day(int& y, int& m, int& d)const;
        static date date_from_string__no_exception(const std::string& _str);
    public:
        enum week_day {
            sun = 0, mon = 1, tue = 2, wed = 3, thu = 4, fri = 5, sat = 6
        };

        enum Month {
            jan = 1, feb = 2, mar = 3, apr = 4, may = 5, jun = 6, jul = 7,
            aug = 8, sep = 9, oct = 10, nov = 11, dec = 12
        };
    protected:
        static const int days_in_year;
        static const int days_in_leap_year;
    public:
        static const uint32_t undefined;

        static const date min;

        static const date max;

        static const date gregorian_start;

        static const int min_julian_day;

        static const int max_julian_day;

        static const int undefined_julian_day;

        static const int min_yyyymmdd;

        static const int max_yyyymmdd;
    public:
        static bool is_leap_year(int year);

        date(const date& other);

        date(const char* date_str);

        date(const variant& variant);

        explicit date(uint32_t yyyymmdd = date::undefined);

        date(int year, int month, int day);

        date& operator= (const date& other);

        void assign(const date&, bool _error_on_undefined = true);

        void set_to_now(tsa::local_or_utc_time_select lu);

        void clear(void);

        void julian_day(int julian_day);

        int julian_day(void) const;
    public:
        struct bin_rep {
            uint32_t part_a;
            uint32_t part_b;
        };
        void reset_from_bin_rep(const bin_rep&);
        bin_rep get_bin_rep(void) const;
    public:
        int GetJulianMonth(void) const;
        int GetJulianQuarter(void) const;
        int GetJulianSemester(void) const;
        static int GetJulianMonth(int nJulDay);
        static int GetJulianQuarter(int nJulDay);
        static int GetJulianSemester(int nJulDay);
        int year(void) const;

        int month(void) const;

        int day_of_month(void) const;

        int day_of_year(void) const;

        week_day day_of_week(void) const;

        bool is_weekend(void) const;

        void yyyymmdd(uint32_t yyyymmdd);

        uint32_t yyyymmdd(void) const;

        std::string to_string(const char* format) const;

        std::string to_string(void)const;
    public:
        
    private:
        // deprecated: 
        void set_old(const std::string& date_string, const char* format_string);
    public:

        void set_from_string(const std::string& date_string, const char* format_string = "");

        void set_from_iso_string(const std::string& iso_date_string);

        void set(uint32_t year, uint32_t month, uint32_t day);

        bool in_leap_year(void) const;

        static bool _IsLeapYear(int year);

        static bool is_valid(int year, int month, int day);
        bool is_valid(void) const;
        bool not_defined(void) const;
        bool defined(void) const;
        void verify_defined(void) const;

        friend date operator+ (const date& date, const duration& num_days);

        friend date operator- (const date& Left, const duration& num_days);

        void operator+= (const duration& num_days);

        void operator-= (const duration& num_days);

        int ApproxNumBusinessDaysBetween(const date&) const;
        date& operator++();
        date operator++ (int);
        date& operator--();
        date operator-- (int);

        void incr_to_next_weekday(void);

        void decr_to_prev_weekday(void);

        void incr(int num_days);

        void decr(int num_days);
    public:
        bool operator== (const date& other) const;

        bool operator!= (const date& other) const;

        bool operator< (const date& other) const;

        bool operator<= (const date& other) const;

        bool operator> (const date& other) const;

        bool operator>= (const date& other) const;

        time_t GetAsSystemTime(local_or_utc_time_select lu = tsa::local_time) const;
public:
        void WriteState(out_storage_stream& stream) const; //soon to be obsolete
        void ReadState(in_storage_stream& stream);
        void raise_parse_error(const std::string& _str, const std::string& _format) const;
    public:
        friend std::ostream& operator<< (std::ostream&, const date& date);
    };

    date operator+ (const date& date, const duration& num_days);

    date operator- (const date& Left, const duration& numDays);

    std::ostream& operator<< (std::ostream& stream, const date& date);



    /*
    ** ====================================================
    ** >>>             class date_time                  <<<
    ** ====================================================
    */

    class  dll_export date_time : public date {
        tsa_declare_testable;
        friend class variant;
        static const std::string s_class_name;
    public:
        static const int64_t microseconds_in_minute;

        static const int64_t microseconds_in_hour;

        static const int64_t microseconds_in_day;

        static const int64_t last_microsecond_in_day;

        static const int64_t microseconds_in_second;

        static const date_time min;

        static const date_time max;
    public:
        static const char undefined_timezone_offset;

        static const uint32_t undefined;

        static const uint32_t now_local;

        static const uint32_t now_utc;
    private:
        int64_t m_usec_since_midnight;
        date_time& add_microsecs(int64_t);
        date_time& subtract_microsecs(int64_t);
        void get_hr_min_sec(uint32_t* hour_ptr, uint32_t* minute_ptr, uint32_t* second_ptr)const;
        string _IntToFixedLengthString(int num, size_t len) const;
    public:
        template<class Archive>
        void serialize(Archive & ar)
        {
            ar(m_julian_day);
            ar(m_time_zone_offset_half_hours);
            ar(m_usec_since_midnight);
        }
    public:

        explicit date_time(uint32_t yyyymmdd = date_time::undefined);

        date_time(const date_time& other);
    public:
        explicit date_time(const std::chrono::time_point<std::chrono::system_clock>& time_point) {
            set(time_point);
        }
    public:

        date_time(const char* date_time_str);

        void verify_defined(void) const;

        //  @brief Sets @b self to an 'undefined' state. defined() will thereafter return false.
        void set_to_null(void);

        bool has_time_zone_offset(void)const;

        int timezone_half_hour_offset(void) const;

        void timezone_half_hour_offset(int);

        double timezone_offset(void)const;

        void timezone_offset(double hours);

        // internal
        char convert_hour_offset_to_half_hour_offset(double hours);

        date_time convert_to_utc(void)const;

        date_time convert_to_time_zone_offset(double new_offset)const;

        static date_time system_time(tsa::local_or_utc_time_select local_or_utc,
            set_timezone_offset_select set_tz_offset_flag);

        static date_time now(void) { return date_time::system_time(tsa::local_time, no_timezone_offset); }

        static date_time local_time(void) { return date_time::system_time(tsa::local_time, no_timezone_offset); }

        static date_time utc_time(set_timezone_offset_select set_tz_offset_flag = no_timezone_offset) 
                              { return date_time::system_time(tsa::utc_time, set_tz_offset_flag); }

        void assign(const tsa::date_time& other, bool error_on_nil = true);

        date_time& operator= (const tsa::date_time&);

        explicit date_time(const date& date);

        date_time(uint32_t year, uint32_t month, uint32_t day);

        date_time(const date& date, uint32_t hour, uint32_t minute, uint32_t second = 0);

        date_time(uint32_t year, uint32_t month, uint32_t day,
            uint32_t hour, uint32_t minute, uint32_t second = 0, uint32_t microseconds = 0);

        date_time(const date& date, uint32_t hour,
            uint32_t minute, uint32_t second, uint32_t microseconds);

        date_time(const variant& variant);

        time_t as_system_time(local_or_utc_time_select local_or_utc = tsa::local_time) const;

        std::chrono::system_clock::time_point as_time_point(local_or_utc_time_select local_or_utc);

        void set(const std::chrono::system_clock::time_point& time_pt,
            local_or_utc_time_select local_or_utc = tsa::local_time);

        //template<typename CLOCK>
        //void set(const std::chrono::time_point<CLOCK>& _time_pt, local_or_utc_time_select _lu = tsa::local_time) {
        //  //time_t tm = CLOCK::to_time_t(_time_pt);
        //  //time_t tm = std::chrono::system_clock::to_time_t(_time_pt);
        //  //set_time_t(tm, _lu);

        //}

        void set_time_t(time_t system_time, local_or_utc_time_select local_or_utc,
            set_timezone_offset_select tz = no_timezone_offset);

        bool defined(void) const;

        void clear(void);
    public:
        tsa::time_of_day time_of_day(void)const;
    public:
        static bool is_valid(int hour, int minute, int second, int millisecond);
        bool is_valid(void) const;
        bool not_defined(void) const;
    public:
        void reset_from_bin_rep(const bin_rep&);
        bin_rep get_bin_rep(void) const;
    public:
        uint32_t hhmmssmmm(void) const;

        uint64_t hhmmssmmmmmm(void) const;

        uint32_t hhmmss(void) const;

        uint32_t hhmm(void) const;

        int64_t microsec_since_midnight(void) const;

        void microsec_since_midnight(int64_t);

        bool is_midnight(void) const;

        uint32_t hour(void) const;

        uint32_t minute(void) const;

        uint32_t second(void) const;

        uint32_t microsec(void) const;

        uint32_t usec(void) const;

        //  Sets the time-of-day from an integer.
        void set_hhmmssmmmmmm(uint64_t hhmmssmmmmmm);

        void set_hhmmss(uint32_t hhmmss);

        void set_hhmm(uint32_t hhmm);

        void set_time(uint32_t hour, uint32_t minute, uint32_t second, uint32_t microsecond);

        void set_time(uint32_t hour, uint32_t minute, uint32_t second);

        void set_time(uint32_t hour, uint32_t minute);

        void set_to_now(local_or_utc_time_select local_or_utc_flag,
            set_timezone_offset_select set_tz_offset_flag = no_timezone_offset);

        std::string to_time_string(const char* format = "hh:mm:ss.f") const;

        std::string to_string(const char* date_format, const char* time_format, char sep) const;

        std::string to_string(char sep = 'T')const;
    public:

        void set_from_string(const std::string& date_time_string, 
            const char* date_format = nullptr, char sep = 'T');

        void set_from_iso_string(const std::string& date_time_string);

        //internal
        string GetReportDateTimeString(const char* dateFormat = "yyyy-mmm-dd");

        void set_date(uint32_t year, uint32_t month, uint32_t day);

        void set_date(const date&);

        void set_date_from_string(const std::string& date_string, const char* date_format);

        void set_time_from_string(const std::string& time_string);
    private:
        void set_string_time__check(const std::string& time_string, const char* format = "hh:mm:ss.f");
    public:
        void verify_both_have_timezone(const date_time& a, const date_time& b)const;

        bool operator== (const date_time& other) const;

        bool operator!= (const date_time& other) const;

        bool operator< (const date_time& other) const;

        bool operator<= (const date_time& other) const;

        bool operator> (const date_time& other) const;

        bool operator>= (const date_time& other) const;

        void incr_date(int num_days = 1);

        void incr_microsec(int64_t n = 1);

        void decr_microsec(int64_t n = 1);
    public:
        void round_down_to_minute(void);
        void round_down_to_second(void);
    public:
        static clock_t clock_cycles(void);
        void write_state(out_storage_stream&) const; //soon to be obsolete
        void read_state(in_storage_stream&);
        //void write(std::ostream&) const;
        //void read(std::istream&);
        friend std::ostream& operator<< (std::ostream&, const date_time&);

    private://hide these members inherited from date (to avoid confusion)
        date& operator++();
        date operator++ (int);
        date& operator--();
        date operator-- (int);
        void incr(void);
        void incr(int days);
        void decr(int days);
    public:
        void operator+= (const duration& duration);
        void operator-= (const duration& duration);
    };

    typedef date_time time_point;

    std::ostream& operator<< (std::ostream& stream, const date_time& datetime);

    date_time min(const date_time& left, const date_time& right);

    date_time max(const date_time& left, const date_time& right);




    /*
    ** ====================================================
    ** >>>               class duration                 <<<
    ** ====================================================
    */

    class dll_export duration {
        int m_24_hour_periods;
        int64_t m_microseconds;
        static const std::string s_class_name;
    public:
        template<class Archive>
        void serialize(Archive & ar)
        {
            ar(m_24_hour_periods);
            ar(m_microseconds);
        }
    public:
        static duration days(uint64_t);
        static duration hours(uint64_t);
        static duration minutes(uint64_t);
        static duration seconds(uint64_t);
        static duration milliseconds(uint64_t);
        static duration microseconds(uint64_t);
    public:

        duration(uint64_t num_24h_periods, uint64_t microsec_of_day);
        duration(double decimal_24hour_periods);
        duration(const duration&);

        duration(void);
        duration(const date_time& a, const date_time& b);
        bool operator== (const duration& other) const;
        int get_days(void) const;

        int64_t get_microseconds(void) const;

        bool is_zero()const;
    public:

        int64_t to_microseconds(void)const;
        int64_t to_seconds(void)const;

        double to_fractional_days(void) const;

        double to_fractional_years(void) const;
    public:
        void operator+= (const duration& other);
        void operator= (const duration&);
        bool operator< (const duration& rhs);
        bool operator> (const duration& rhs);
        bool operator<= (const duration& rhs);
        bool operator>= (const duration& rhs);
        duration operator/ (double num) const;
        duration operator* (double multiplier) const;

    public:
        void WriteState(out_storage_stream&) const;
        void ReadState(in_storage_stream&);
    };

    std::ostream& operator<< (std::ostream& stream, const duration& ts);

    duration operator+ (const duration& a, const duration& b);
    date_time operator+ (const date_time& a, const duration& b);
    date_time operator- (const date_time& a, const duration& b);
    duration operator- (const date_time& a, const date_time& b);

}// namespace tsa

#endif