time.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_timestamp_h
#define INCL_evo_timestamp_h

#include "string.h"
#include "substring.h"
#include "impl/systime.h"

namespace evo {


namespace impl_time {
    inline int parse_num(int& num, const char*& inp, const char* end) {
        const int OVERFLOW_THRESHOLD = Int::MAX / 10; // not exact, but good enough here
        const char* start = inp;
        num = 0;
        while (inp < end) {
            if (*inp < '0' || *inp > '9')
                break;
            if (num >= OVERFLOW_THRESHOLD) {
                num = 0;
                return Int::MAX; // overflow
            }
            num = (num * 10) + (*inp - '0');
            ++inp;
        }
        return (int)(inp - start);
    }

    inline double parse_frac(const char*& inp, const char* end) {
        double div = 1.0;
        double num = 0.0;
        while (inp < end) {
            if (*inp < '0' || *inp > '9')
                break;
            num = (num * 10) + (*inp - '0');
            div *= 10;
            ++inp;
        }
        num /= div;
        return num;
    }
}

struct Date {
    static const int YEAR_MIN = 1000;       
    static const int YEAR_MAX = 9999;       
    static const int MONTH_MIN = 1;         
    static const int MONTH_MAX = 12;        
    static const int DAY_MIN = 1;           
    static const int DAY_MAX = 31;          
    static const ulong JDN_MIN = 2086302;   
    static const ulong JDN_MOD = 2400000;   

    int year;   
    int month;  
    int day;    

    Date()
        { ::memset(this, 0, sizeof(Date)); }

    Date(int year, int month, int day) : year(year), month(month), day(day) {
    }

    Date(const Date& src)
        { ::memcpy(this, &src, sizeof(Date)); }

    Date& operator=(const Date& src)
        { ::memcpy(this, &src, sizeof(Date)); return *this; }

    bool operator==(const Date& oth) const
        { return (year == oth.year && month == oth.month && day == oth.day); }

    bool operator!=(const Date& oth) const
        { return (year != oth.year || month != oth.month || day != oth.day); }

    bool operator<(const Date& oth) const
        { return (year < oth.year || (year == oth.year && (month < oth.month || (month == oth.month && day < oth.day)))); }

    bool operator<=(const Date& oth) const
        { return (year < oth.year || (year == oth.year && (month < oth.month || (month == oth.month && day <= oth.day)))); }

    bool operator>(const Date& oth) const
        { return (year > oth.year || (year == oth.year && (month > oth.month || (month == oth.month && day > oth.day)))); }

    bool operator>=(const Date& oth) const
        { return (year > oth.year || (year == oth.year && (month > oth.month || (month == oth.month && day >= oth.day)))); }

    int compare(const Date& oth) const {
        if (year == oth.year) {
            if (month == oth.month) {
                if (day == oth.day)
                    return 0;
                else if (day < oth.day)
                    return -1;
            } else if (month < oth.month)
                return -1;
        } else if (year < oth.year)
            return -1;
        return 1;
    }

    ulong get_jdn() const {
        if (!validate())
            return 0;
        return calc_jdn(year, month, day);
    }

    bool validate() const {
        return (year  >= YEAR_MIN  && year  <= YEAR_MAX &&
                month >= MONTH_MIN && month <= MONTH_MAX &&
                day   >= DAY_MIN   && day   <= days_per_month(month, year));
    }

    void set() {
        year = month = day = 0;
    }

    bool set(int new_year, int new_month, int new_day) {
        if ( new_year  < YEAR_MIN  || new_year  > YEAR_MAX ||
             new_month < MONTH_MIN || new_month > MONTH_MAX ||
             new_day   < DAY_MIN   || new_day   > days_per_month(new_month, new_year) )
            return false;
        year  = new_year;
        month = new_month;
        day   = new_day;
        return true;
    }

    bool set_jdn(ulong jdn) {
        if (jdn < JDN_MIN)
            return false;
        // https://en.wikipedia.org/wiki/Julian_day
        const long f = jdn + 1401 + (((4 * jdn + 274277) / 146097) * 3) / 4 + -38;
        const long e = 4 * f + 3;
        const long g = (e % 1461) / 4;
        const long h = 5 * g + 2;
        day   = (int)((h % 153) / 5 + 1);
        month = (int)(((h / 153 + 2) % 12) + 1);
        year  = (int)((e / 1461) - 4716 + (12 + 2 - month) / 12);
        return true;
    }

    void set_utc() {
        int hour, minute, second, msecond;
        SysTimestamp::get_wall_datetime_fields_utc(year, month, day, hour, minute, second, msecond);
    }

    void set_local() {
        int hour, minute, second, msecond;
        SysTimestamp::get_wall_datetime_fields_local(year, month, day, hour, minute, second, msecond);
    }

    bool add_years(int years) {
        if (!validate())
            return false;
        year += years;
        const int maxday = days_per_month(month, year);
        if (day > maxday)
            day = maxday;
        return (year >= YEAR_MIN && year <= YEAR_MAX);
    }

    bool add_months(int months) {
        if (!validate())
            return false;
        year += (months / MONTH_MAX);
        month += (months % MONTH_MAX);
        if (month > MONTH_MAX) {
            ++year;
            month -= MONTH_MAX;
        } else if (month < MONTH_MIN) {
            --year;
            month += MONTH_MAX;
        }
        const int maxday = days_per_month(month, year);
        if (day > maxday)
            day = maxday;
        return (year >= YEAR_MIN && year <= YEAR_MAX);
    }

    bool add_days(int days) {
        const ulong jdn = get_jdn();
        if (jdn == 0)
            return false;
        set_jdn(jdn + days);
        return (year >= YEAR_MIN && year <= YEAR_MAX);
    }

    bool parse_std_impl(const char*& inp, const char* end) {
        year = month = day = 0;
        for (char delim;;) {
            // Year
            int digits = impl_time::parse_num(year, inp, end);
            switch (digits) {
                case 4:
                    break;
                case 7: {
                    // Ordinal date (YYYYDDD)
                    const int year_day = (year % 1000);
                    year /= 1000;
                    const int days_in_year = (is_leap_year(year) ? 366 : 365);
                    if (year_day <= 0 || year_day > days_in_year)
                        return false;
                    month = 1;
                    day = 1;
                    return add_days(year_day - 1);
                }
                case 8:
                    // YYYYMMDD
                    day = (year % 100);
                    year /= 100;
                    if (day < DAY_MIN)
                        return false;

                    month = (year % 100);
                    year /= 100;
                    if (month < MONTH_MIN || month > MONTH_MAX || day > days_per_month(month, year))
                        return false;

                    inp += digits;
                    return true;
                default:
                    return false;
            }
            if (inp >= end)
                return false;

            // Delim
            if (*inp != '-' && *inp != '/' && *inp != '.' && *inp != ' ')
                return false;
            delim = *inp;
            ++inp;

            // Month
            digits = impl_time::parse_num(month, inp, end);
            switch (digits) {
                case 1:
                case 2:
                    if (month < MONTH_MIN || month > MONTH_MAX)
                        return false;
                    break;
                case 3: {
                    // Ordinal date (YYYY-DDD)
                    const int year_day = month;
                    const int days_in_year = (is_leap_year(year) ? 366 : 365);
                    if (year_day <= 0 || year_day > days_in_year)
                        return false;
                    month = 1;
                    day = 1;
                    return add_days(year_day - 1);
                }
                default:
                    return false;
            }

            // Delim
            if (*inp != delim)
                return false;
            ++inp;

            // Day
            digits = impl_time::parse_num(day, inp, end);
            if (digits > 2 || day < DAY_MIN || day > days_per_month(month, year))
                return false;
            break;
        }
        return true;
    }

    bool parse(const SubString& str) {
        const char* p = str.data();
        return parse_std_impl(p, p + str.size());
    }

    template<class T>
    T& format(T& out, char delim='-') const {
        out << FmtInt(year, fDEC, fPREFIX0, 4, '0');
        if (delim > 0)
            out << delim << FmtInt(month, fDEC, fPREFIX0, 2, '0') << delim;
        else
            out << FmtInt(month, fDEC, fPREFIX0, 2, '0');
        out << FmtInt(day, fDEC, fPREFIX0, 2, '0');
        return out;
    }

    template<class T>
    T& format_yearday(T& out, char delim='-') {
        out << FmtInt(year, fDEC, fPREFIX0, 4, '0');
        if (delim > 0)
            out << delim;
        if (month > 0 && day > 0)
            out << FmtULong(calc_jdn(year, month, day) - calc_jdn(year, 1, 1) + 1, fDEC, fPREFIX0, 3, '0');
        else
            out << FmtInt(1, fDEC, fPREFIX0, 3, '0');
        return out;
    }

    static bool is_leap_year(int year) {
        return (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0));
    }

    static int days_per_month(int month, bool leap_year) {
        static const int DAYS[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        assert( month >= MONTH_MIN && month <= MONTH_MAX );
        if (month == 2 && leap_year)
            return 29;
        return DAYS[month - 1];
    }

    static int days_per_month(int month, int year) {
        return days_per_month(month, is_leap_year(year));
    }

    static SubString month_name(int month) {
        static const char* MONTHS[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
        if (month < MONTH_MIN || month > MONTH_MAX)
            return SubString();
        return MONTHS[month - 1];
    }

    static SubString month_name3(int month) {
        static const char* MONTHS[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
        if (month < MONTH_MIN || month > MONTH_MAX)
            return SubString();
        return MONTHS[month - 1];
    }

    static ulong calc_jdn(int year, int month, int day) {
        // https://en.wikipedia.org/wiki/Julian_day
        return (1461 * (year + 4800 + (month - 14) / 12)) / 4 +
            (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12 -
            (3 * ((year + 4900 + (month - 14) / 12) / 100)) / 4 + day - 32075;
    }
};


struct TimeOfDay {
    static const int HOUR_MIN = 0;      
    static const int HOUR_MAX = 23;     
    static const int MINUTE_MIN = 0;    
    static const int MINUTE_MAX = 59;   
    static const int SECOND_MIN = 0;    
    static const int SECOND_MAX = 60;   
    static const int MSECOND_MIN = 0;   
    static const int MSECOND_MAX = 999; 

    static const int HOURS_PER_DAY = 24;    
    static const int MIN_PER_HOUR = 60;     
    static const int MIN_PER_DAY  = 1440;   
    static const int SEC_PER_MIN  = 60;     
    static const int SEC_PER_HOUR = 3600;   
    static const int SEC_PER_DAY  = 86400;  
    static const int MSEC_PER_SEC = 1000;   
    static const int MSEC_PER_MIN = 60000;  
    static const long MSEC_PER_HOUR = 3600000;  
    static const long MSEC_PER_DAY  = 86400000; 

    int hour;       
    int minute;     
    int second;     
    int msecond;    

    TimeOfDay()
        { ::memset(this, 0, sizeof(TimeOfDay)); }

    TimeOfDay(int hour, int min=0, int sec=0, int msec=0) : hour(hour), minute(min), second(sec), msecond(msec) {
    }

    TimeOfDay(const TimeOfDay& src)
        { ::memcpy(this, &src, sizeof(TimeOfDay)); }

    TimeOfDay& operator=(const TimeOfDay& src)
        { ::memcpy(this, &src, sizeof(TimeOfDay)); return *this; }

    bool operator==(const TimeOfDay& oth) const
        { return (hour == oth.hour && minute == oth.minute && second == oth.second && msecond == oth.msecond); }

    bool operator!=(const TimeOfDay& oth) const
        { return (hour != oth.hour || minute != oth.minute || second != oth.second || msecond != oth.msecond); }

    bool operator<(const TimeOfDay& oth) const
        { return (hour < oth.hour || (hour == oth.hour && (minute < oth.minute || (minute == oth.minute && (second < oth.second || (second == oth.second && msecond < oth.msecond)))))); }

    bool operator<=(const TimeOfDay& oth) const
        { return (hour < oth.hour || (hour == oth.hour && (minute < oth.minute || (minute == oth.minute && (second < oth.second || (second == oth.second && msecond <= oth.msecond)))))); }

    bool operator>(const TimeOfDay& oth) const
        { return (hour > oth.hour || (hour == oth.hour && (minute > oth.minute || (minute == oth.minute && (second > oth.second || (second == oth.second && msecond > oth.msecond)))))); }

    bool operator>=(const TimeOfDay& oth) const
        { return (hour > oth.hour || (hour == oth.hour && (minute > oth.minute || (minute == oth.minute && (second > oth.second || (second == oth.second && msecond >= oth.msecond)))))); }

    int compare(const TimeOfDay& oth) const {
        if (hour == oth.hour) {
            if (minute == oth.minute) {
                if (second == oth.second) {
                    if (msecond == oth.msecond)
                        return 0;
                    else if (msecond < oth.msecond)
                        return -1;
                } else if (second < oth.second)
                    return -1;
            } else if (minute < oth.minute)
                return -1;
        } else if (hour < oth.hour)
            return -1;
        return 1;
    }

    double get_fraction() const {
        return ((double)hour / HOURS_PER_DAY) +
               ((double)minute / MIN_PER_DAY) +
               ((double)second / SEC_PER_DAY);
    }

    int get_days() const {
        return (hour / HOURS_PER_DAY);
    }

    int get_days(int& result_hour) const {
        int days = (hour / HOURS_PER_DAY);
        result_hour = hour - (days * HOURS_PER_DAY);
        if (result_hour < 0) {
            --days;
            result_hour += HOURS_PER_DAY;
        }
        return days;
    }

    bool validate(bool allow_hour_overflow=false) const {
        return (hour >= HOUR_MIN && (allow_hour_overflow || hour <= HOUR_MAX) &&
                minute >= MINUTE_MIN && minute <= MINUTE_MAX &&
                second >= SECOND_MIN && second <= SECOND_MAX &&
                msecond >= MSECOND_MIN && msecond <= MSECOND_MAX);
    }

    void set()
         { hour = minute = second = msecond = 0; }

    bool set(int new_hour, int new_minute=0, int new_second=0, int new_msecond=0) {
        if ( new_hour < HOUR_MIN || new_hour > HOUR_MAX ||
             new_minute < MINUTE_MIN || new_minute > MINUTE_MAX ||
             new_second < SECOND_MIN || new_second > SECOND_MAX ||
             new_msecond < MSECOND_MIN || new_msecond > MSECOND_MAX )
            return false;
        hour = new_hour;
        minute = new_minute;
        second = new_second;
        msecond = new_msecond;
        return true;
    }

    void set_fraction(double tm, int msec=0) {
        hour = (int)(tm * HOURS_PER_DAY);
        tm -= (double)hour / HOURS_PER_DAY;
        minute = (int)(tm * MIN_PER_DAY);
        tm -= (double)minute / MIN_PER_DAY;
        second = (int)(tm * SEC_PER_DAY);
        msecond = msec;
    }

    void set_utc() {
        int year, month, day;
        SysTimestamp::get_wall_datetime_fields_utc(year, month, day, hour, minute, second, msecond);
    }

    void set_local() {
        int year, month, day;
        SysTimestamp::get_wall_datetime_fields_local(year, month, day, hour, minute, second, msecond);
    }

    void add_minutes(int minutes) {
        minute += minutes;
        int newhours = (minute / MIN_PER_HOUR);
        hour += newhours;
        minute -= (newhours * MIN_PER_HOUR);
        if (minute < 0) {
            --hour;
            minute += MIN_PER_HOUR;
        }
    }

    void add_seconds(int seconds) {
        if (second == 60)
            second = 59; // ignore leap second so it doesn't throw off the math

        long total_seconds = (minute * SEC_PER_MIN) + second + seconds;
        int newhours = (total_seconds / SEC_PER_HOUR);
        total_seconds -= (newhours * SEC_PER_HOUR);

        hour += newhours;
        minute = (total_seconds / SEC_PER_MIN);
        total_seconds -= (minute * SEC_PER_MIN);

        second = (int)total_seconds;
        if (second < 0) {
            --minute;
            second += SEC_PER_MIN;
        }
        if (minute < 0) {
            --hour;
            minute += MIN_PER_HOUR;
        }
    }

    void add_milliseconds(int milliseconds) {
        msecond += milliseconds;
        int newseconds = (msecond / MSEC_PER_SEC);
        msecond -= (newseconds * MSEC_PER_SEC);
        if (msecond < 0) {
            --newseconds;
            msecond += MSEC_PER_SEC;
        }
        add_seconds(newseconds);
    }

    bool parse_std_impl(const char*& inp, const char* end, bool allow_hour_overflow=false) {
        const double ROUND_MSEC = 0.001;
        hour = minute = second = msecond = 0;
        for (;;) {
            // Hour
            int digits = impl_time::parse_num(hour, inp, end);
            switch (digits) {
                case 1:
                case 2:
                    break;
                case 4:
                    minute = hour % 100;
                    hour /= 100;
                    if ( hour < HOUR_MIN || (hour > HOUR_MAX && !allow_hour_overflow) ||
                         minute < MINUTE_MIN || minute > MINUTE_MAX )
                        return false;
                    if (inp < end && (*inp == '.' || *inp == ','))
                        goto frac_min;
                    return true;
                case 6:
                    second = hour % 100;
                    hour /= 100;
                    minute = hour % 100;
                    hour /= 100;
                    if ( hour < HOUR_MIN || (hour > HOUR_MAX && !allow_hour_overflow) ||
                         minute < MINUTE_MIN || minute > MINUTE_MAX ||
                         second < SECOND_MIN || second > SECOND_MAX )
                        return false;
                    goto endfrac;
                default:
                    return false; // invalid
            }

            if (hour < HOUR_MIN || (hour > HOUR_MAX && !allow_hour_overflow))
                return false;
            if (inp >= end)
                break;

            if (*inp == '.' || *inp == ',') {
                // Fractional hour
                double frac = impl_time::parse_frac(++inp, end);
                frac *= MIN_PER_HOUR;
                minute = (int)frac;
                frac -= minute;

                frac *= SEC_PER_MIN;
                second = (int)frac;
                frac -= second;

                msecond = (int)((frac * MSEC_PER_SEC) + ROUND_MSEC);
                return true;
            }
            if (*inp != ':')
                break;
            ++inp;

            // Minute
            digits = impl_time::parse_num(minute, inp, end);
            switch (digits) {
                case 1:
                case 2:
                    break;
                default:
                    return false; // invalid
            }
            if (minute < MINUTE_MIN || minute > MINUTE_MAX)
                return false;

            if (*inp == '.' || *inp == ',') {
                // Fractional minute
            frac_min:
                double frac = impl_time::parse_frac(++inp, end);
                frac *= SEC_PER_MIN;
                second = (int)frac;
                frac -= second;

                msecond = (int)((frac * MSEC_PER_SEC) + ROUND_MSEC);
                break;
            }
            if (*inp != ':')
                break;
            ++inp;

            // Second
            digits = impl_time::parse_num(second, inp, end);
            switch (digits) {
                case 1:
                case 2:
                    break;
                default:
                    return false; // invalid
            }
            if (second < SECOND_MIN || second > SECOND_MAX)
                return false;

        endfrac:
            if (*inp == '.' || *inp == ',') {
                // Fractional second, i.e. millisecond
                msecond = (int)((impl_time::parse_frac(++inp, end) * MSEC_PER_SEC) + ROUND_MSEC);
                break;
            }

            break;
        }
        return true;
    }

    bool parse(const SubString& str, bool allow_hour_overflow=false) {
        const char* p = str.data();
        return parse_std_impl(p, p + str.size(), allow_hour_overflow);
    }

    template<class T>
    T& format(T& out, char delim=':', char msdelim=0) const {
        out << FmtInt(hour, fDEC, fPREFIX0, 2, '0');
        if (delim > 0)
            out << delim << FmtInt(minute, fDEC, fPREFIX0, 2, '0') << delim;
        else
            out << FmtInt(minute, fDEC, fPREFIX0, 2, '0');
        out << FmtInt(second, fDEC, fPREFIX0, 2, '0');
        if (msecond > 0 && msdelim > 0)
            out << msdelim << FmtInt(msecond, fDEC, fPREFIX0, 3, '0');
        return out;
    }
};


struct TimeZoneOffset {
    static const int OFFSET_MIN = -1439;        
    static const int OFFSET_MAX = 1439;         
    static const int OFFSET_NULL = Int::MIN;    

    int minutes;    

    TimeZoneOffset()
        { minutes = OFFSET_NULL; }

    TimeZoneOffset(int minutes) : minutes(minutes) {
    }

    TimeZoneOffset(int hours, int hour_minutes) {
        if (hours < 0)
            minutes = (hours * TimeOfDay::MIN_PER_HOUR) - hour_minutes;
        else
            minutes = (hours * TimeOfDay::MIN_PER_HOUR) + hour_minutes; 
    }

    TimeZoneOffset(const TimeZoneOffset& src)
        { minutes = src.minutes; }

    TimeZoneOffset& operator=(const TimeZoneOffset& src)
        { minutes = src.minutes; return *this; }

    bool operator==(const TimeZoneOffset& oth) const
        { return (minutes == oth.minutes); }

    bool operator!=(const TimeZoneOffset& oth) const
        { return (minutes != oth.minutes); }

    bool operator<(const TimeZoneOffset& oth) const
        { return (minutes < oth.minutes); }

    bool operator<=(const TimeZoneOffset& oth) const
        { return (minutes <= oth.minutes); }

    bool operator>(const TimeZoneOffset& oth) const
        { return (minutes > oth.minutes); }

    bool operator>=(const TimeZoneOffset& oth) const
        { return (minutes >= oth.minutes); }

    int compare(const TimeZoneOffset& oth) const
        { return (minutes == oth.minutes ? 0 : (minutes < oth.minutes ? -1 : 1)); }

    bool null() const 
        { return minutes == OFFSET_NULL; }

    bool validate() const
        { return (minutes == OFFSET_NULL || (minutes >= OFFSET_MIN && minutes <= OFFSET_MAX)); }

    void set()
        { minutes = OFFSET_NULL; }

    bool set(int new_minutes) {
        if (new_minutes == OFFSET_NULL || (new_minutes >= OFFSET_MIN && new_minutes <= OFFSET_MAX)) {
            minutes = new_minutes;
            return true;
        }
        return false;
    }

    bool set(int hours, int hour_minutes) {
        if ( hours <= -TimeOfDay::HOURS_PER_DAY || hours >= TimeOfDay::HOURS_PER_DAY ||
             hour_minutes < TimeOfDay::MINUTE_MIN || hour_minutes > TimeOfDay::MINUTE_MAX )
            return false;
        if (hours < 0)
            minutes = (hours * TimeOfDay::MIN_PER_HOUR) - hour_minutes;
        else
            minutes = (hours * TimeOfDay::MIN_PER_HOUR) + hour_minutes; 
        return true;
    }

    TimeZoneOffset& set_utc() {
        minutes = 0;
        return *this;
    }

    TimeZoneOffset& set_local() {
        minutes = SysTimestamp::tz_get_offset();
        return *this;
    }

    bool parse_std_impl(const char*& inp, const char* end, bool required=false) {
        minutes = OFFSET_NULL;
        if (inp >= end)
            return !required; // no offset

        int neg_mult;
        switch (*inp) {
            case 'Z':
            case 'z':
                minutes = 0;
                return true; // UTC
            case '+':
                neg_mult = 1;
                break;
            case '-':
                neg_mult = -1;
                break;
            default:
                if (*inp >= '0' && *inp <= '9')
                    return false; // invalid
                return !required; // no offset
        }

        int hours = 0;
        int digits = impl_time::parse_num(hours, ++inp, end);
        switch (digits) {
            case 1:
            case 2:
                break;
            case 4:
                minutes = (hours / 100 * TimeOfDay::MIN_PER_HOUR * neg_mult) + (hours % 100 * neg_mult);
                return (minutes >= OFFSET_MIN && minutes <= OFFSET_MAX);
            default:
                return false;
        }
        if (hours >= TimeOfDay::HOURS_PER_DAY)
            return false;

        if (inp >= end || *inp != ':') {
            minutes = (hours * TimeOfDay::MIN_PER_HOUR * neg_mult);
            return true;
        }
        if (++inp >= end)
            return false;

        int hour_minutes = 0;
        digits = impl_time::parse_num(hour_minutes, inp, end);
        if (digits > 2 || hour_minutes > TimeOfDay::MINUTE_MAX)
            return false;
        
        minutes = (hours * TimeOfDay::MIN_PER_HOUR * neg_mult) + (hour_minutes * neg_mult);
        return true;
    }

    bool parse(const SubString& str, bool required=false) {
        const char* p = str.data();
        return parse_std_impl(p, p + str.size(), required);
    }

    template<class T>
    T& format(T& out, char delim=':', bool allow_z=true) const {
        if (minutes == OFFSET_NULL)
            return out;
        if (allow_z && minutes == 0) {
            out << 'Z';
        } else {
            int hours = minutes / 60;
            int hour_minutes = minutes % 60;
            if (hours < 0) {
                out << '-';
                hours *= -1;
                hour_minutes *= -1;
            } else
                out << '+';
            out << FmtInt(hours, fDEC, fPREFIX0, 2, '0');
            if (delim > 0)
                out << delim;
            out << FmtInt(hour_minutes, fDEC, fPREFIX0, 2, '0');
        }
        return out;
    }
};


struct DateTime {
    static const int   OFFSET_NULL = TimeZoneOffset::OFFSET_NULL;     
    static const ulong JDN_MIN     = Date::JDN_MIN;                   

    Date      date;     
    TimeOfDay time;     
    TimeZoneOffset tz;  

    DateTime() {
    }

    DateTime(int year, int month, int day, int hour=0, int minute=0, int second=0, int msecond=0, int tz_offset=OFFSET_NULL) :
        date(year, month, day), time(hour, minute, second, msecond), tz(tz_offset) {
    }

    DateTime(const DateTime& src) : date(src.date), time(src.time), tz(src.tz) {
    }

    DateTime(const Date& date) : date(date) {
    }

    DateTime(const Date& date, const TimeOfDay& time) : date(date), time(time) {
    }

    DateTime(const Date& date, const TimeOfDay& time, const TimeZoneOffset& tz) : date(date), time(time), tz(tz) {
    }

    DateTime(const TimeZoneOffset& tz) : tz(tz) {
    }

    DateTime& operator=(const DateTime& src) {
        date = src.date;
        time = src.time;
        tz   = src.tz;
        return *this;
    }

    bool operator==(const DateTime& oth) const
        { return (compare_op_helper(oth) == 0); }

    bool operator!=(const DateTime& oth) const
        { return (compare_op_helper(oth) != 0); }

    bool operator<(const DateTime& oth) const
        { return (compare_op_helper(oth) < 0); }

    bool operator<=(const DateTime& oth) const
        { return (compare_op_helper(oth) <= 0); }

    bool operator>(const DateTime& oth) const
        { return (compare_op_helper(oth) > 0); }

    bool operator>=(const DateTime& oth) const
        { return (compare_op_helper(oth) >= 0); }

    int compare(const DateTime& oth) const
        { return compare_op_helper(oth); }

    bool validate() const
        { return (date.validate() && time.validate() && tz.validate()); }

    double get_jdn_dt() const
        { return date.get_jdn() + time.get_fraction(); }

    DateTime& set() {
        date.set();
        time.set();
        tz.set();
        return *this;
    }

    bool set(int year, int month, int day, int hour=0, int minute=0, int second=0, int msecond=0)
        { return (date.set(year, month, day) && time.set(hour, minute, second, msecond)); }

    bool set_jdn_dt(double tm, int msec=0) {
        if (tm < JDN_MIN || !date.set_jdn((ulong)tm))
            return false;
        time.set_fraction(tm - (long)tm, msec);
        return true;
    }

    DateTime& set_utc() {
        SysTimestamp::get_wall_datetime_fields_utc(date.year, date.month, date.day, time.hour, time.minute, time.second, time.msecond);
        tz.set_utc();
        return *this;
    }

    DateTime& set_local() {
        SysTimestamp::get_wall_datetime_fields_local(date.year, date.month, date.day, time.hour, time.minute, time.second, time.msecond, tz.minutes);
        return *this;
    }

    DateTime& set_local_notz() {
        SysTimestamp::get_wall_datetime_fields_local(date.year, date.month, date.day, time.hour, time.minute, time.second, time.msecond);
        tz.set();
        return *this;
    }

    bool add_years(int years)
        { return date.add_years(years); }

    bool add_months(int months)
        { return date.add_months(months); }

    bool add_days(int days)
        { return date.add_days(days); }

    bool add_hours(int hours)
        { time.hour += hours; return date.add_days(time.get_days(time.hour)); }

    bool add_minutes(int minutes)
        { time.add_minutes(minutes); return date.add_days(time.get_days(time.hour)); }

    bool add_seconds(int seconds)
        { time.add_seconds(seconds); return date.add_days(time.get_days(time.hour)); }

    bool add_milliseconds(int msec)
        { time.add_milliseconds(msec); return date.add_days(time.get_days(time.hour)); }

    bool parse_std_impl(const char*& inp, const char* end) {
        if (date.parse_std_impl(inp, end)) {
            if (inp < end) {
                switch (*inp) {
                    case 'T':
                    case 't':
                    case '-':
                    case ':':
                    case '_':
                    case '/':
                    case ',':
                    case '.':
                    case '@':
                        if (!time.parse_std_impl(++inp, end))
                            return false;
                        date.add_days(time.get_days(time.hour));
                        break;
                    default:
                        time.set();
                        break;
                }
                return tz.parse_std_impl(inp, end);
            } else {
                time.set();
                tz.set();
            }
            return true;
        }
        return false;
    }

    bool parse(const SubString& str) {
        const char* p = str.data();
        return parse_std_impl(p, p + str.size());
    }

    template<class T>
    T& format(T& out, char dt_delim='T', char d_delim='-', char t_delim=':', char msec_delim=0, char tz_delim=':') const {
        date.format(out, d_delim);
        if (dt_delim > 0)
            out << dt_delim;
        time.format(out, t_delim, msec_delim);
        tz.format(out, tz_delim);
        return out;
    }

    template<class T>
    T& format_std(T& out, char dt_delim='T', char msec_delim=0) const
        { return format(out, dt_delim, '-', ':', msec_delim, ':'); }

    template<class T>
    T& format_nodelim(T& out, char dt_delim='T', char msec_delim=0) const
        { return format(out, dt_delim, 0, 0, msec_delim, 0); }

private:
    int compare_op_helper(const DateTime& oth) const {
        int cmp;
        if (tz.minutes == oth.tz.minutes || tz.null() || oth.tz.null()) {
            cmp = date.compare(oth.date);
            if (cmp == 0)
                cmp = time.compare(oth.time);
        } else {
            DateTime tmp(*this);
            tmp.add_minutes(oth.tz.minutes - tz.minutes);
            cmp = tmp.date.compare(oth.date);
            if (cmp == 0)
                cmp = tmp.time.compare(oth.time);
        }
        return cmp;
    }
};


}
#endif