datetime.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_TIME_DATETIME_HPP__
#define NEFORCE_CORE_TIME_DATETIME_HPP__

 
#include "NeForce/core/utility/packages.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API date : public iobject<date>, public icommon<date> {
public:
    using date_type = int32_t; 
 
private:
    date_type year_ = 1970; 
    date_type month_ = 1;   
    date_type day_ = 1;     
 
public:
    static constexpr int32_t month_days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 
public:
    constexpr date() noexcept = default;
 
    NEFORCE_CONSTEXPR20 ~date() = default;

    constexpr explicit date(date_type year, const date_type month, const date_type day) noexcept {
        if (is_valid(year, month, day)) {
            year_ = year;
            month_ = month;
            day_ = day;
        }
    }
 
    constexpr date(const date&) noexcept = default;
    constexpr date& operator=(const date&) noexcept = default;
    constexpr date(date&&) noexcept = default;
    constexpr date& operator=(date&&) noexcept = default;

    NEFORCE_NODISCARD constexpr date_type year() const noexcept { return year_; }

    NEFORCE_NODISCARD constexpr date_type month() const noexcept { return month_; }

    NEFORCE_NODISCARD constexpr date_type day() const noexcept { return day_; }

    static constexpr bool is_valid(date_type year, date_type month, date_type day) noexcept {
        if (year < 1900 || year > 9999) {
            return false;
        }
        if (month < 1 || month > 12) {
            return false;
        }
        return day > 0 && day <= days_of_month(year, month);
    }

    NEFORCE_NODISCARD constexpr bool is_valid() const noexcept { return is_valid(year_, month_, day_); }

    static constexpr date epoch() noexcept { return date{}; }

    static constexpr bool is_leap_year(const date_type year) noexcept {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    }

    NEFORCE_NODISCARD constexpr date_type days_of_week() const noexcept {
        date_type y = year_;
        date_type m = month_;
        const date_type d = day_;
        if (m < 3) {
            y--;
            m += 12;
        }
        return (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400 + 1) % 7;
    }

    static constexpr date_type days_of_month(const date_type year, const date_type month) noexcept {
        date_type day = month_days[month - 1];
        if (month == 2 && is_leap_year(year)) {
            day += 1;
        }
        return day;
    }

    NEFORCE_NODISCARD constexpr date_type days_of_year() const noexcept {
        date_type days = 0;
        for (date_type i = 1; i < month_; ++i) {
            days += days_of_month(year_, i);
        }
        return days + day_;
    }

    NEFORCE_NODISCARD constexpr int64_t to_julian_day() const noexcept {
        const date_type a = (14 - month_) / 12;
        const date_type year = year_ + 4800 - a;
        const date_type month = month_ + 12 * a - 3;
        return day_ + (153 * month + 2) / 5 + 365 * year + year / 4 - year / 100 + year / 400 - 32045;
    }

    static constexpr date from_julian_day(const int64_t julian_day) noexcept {
        const int64_t a = julian_day + 32044;
        const int64_t b = (4 * a + 3) / 146097;
        const int64_t c = a - (146097 * b) / 4;
        const int64_t d = (4 * c + 3) / 1461;
        const int64_t e = c - (1461 * d) / 4;
        const int64_t m = (5 * e + 2) / 153;
 
        const auto day = static_cast<date_type>(e - (153 * m + 2) / 5 + 1);
        const auto month = static_cast<date_type>(m + 3 - 12 * (m / 10));
        const auto year = static_cast<date_type>(100 * b + d - 4800 + (m / 10));
 
        return date(year, month, day);
    }

    constexpr void clear() noexcept {
        year_ = 1970;
        month_ = 1;
        day_ = 1;
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const date& rhs) const noexcept {
        return year_ == rhs.year_ && month_ == rhs.month_ && day_ == rhs.day_;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const date& rhs) const noexcept {
        if (year_ < rhs.year_) {
            return true;
        }
        if (year_ == rhs.year_ && month_ < rhs.month_) {
            return true;
        }
        if (year_ == rhs.year_ && month_ == rhs.month_ && day_ < rhs.day_) {
            return true;
        }
        return false;
    }

    constexpr date& operator+=(const date_type day) noexcept {
        if (day == 0) {
            return *this;
        }
        if (day < 0) {
            return *this -= -day;
        }
 
        if (day > 365) {
            const int64_t jd = to_julian_day() + day;
            *this = from_julian_day(jd);
            return *this;
        }
 
        date_type remaining = day;
        while (remaining > 0) {
            const date_type days_in_month = days_of_month(year_, month_);
            const date_type available = days_in_month - day_ + 1;
 
            if (remaining < available) {
                day_ += remaining;
                break;
            }
 
            remaining -= available;
            day_ = 1;
            if (++month_ > 12) {
                month_ = 1;
                ++year_;
            }
        }
        return *this;
    }

    constexpr date& operator-=(const date_type day) noexcept {
        if (day < 0) {
            return *this += -day;
        }
 
        day_ -= day;
        while (day_ <= 0) {
            if (--month_ == 0) {
                month_ = 12;
                year_--;
            }
            day_ += days_of_month(year_, month_);
        }
        return *this;
    }

    constexpr date operator+(const date_type day) const noexcept {
        date ret(*this);
        ret += day;
        return ret;
    }

    constexpr date operator-(const date_type day) const noexcept {
        date ret(*this);
        ret -= day;
        return ret;
    }

    constexpr date& operator++() {
        *this += 1;
        return *this;
    }

    constexpr date operator++(int) {
        const date ret(*this);
        *this += 1;
        return ret;
    }

    constexpr date_type operator-(const date& other) const noexcept {
        return static_cast<date_type>(to_julian_day() - other.to_julian_day());
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept {
        constexpr hash<date_type> hasher;
        return hasher(day()) ^ hasher(month()) ^ hasher(year());
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const {
        return _NEFORCE format("{:04d}-{:02d}-{:02d}", year(), month(), day());
    }

    NEFORCE_NODISCARD constexpr static date parse(const string_view view) {
        if (view.size() != 10 || view[4] != '-' || view[7] != '-') {
            NEFORCE_THROW_EXCEPTION(value_exception("Wrong string formation."));
        }
        const date_type year = integer32::parse(view.substr(0, 4)).value();
        const date_type month = integer32::parse(view.substr(5, 2)).value();
        const date_type day = integer32::parse(view.substr(8, 2)).value();
        return date(year, month, day);
    }

    constexpr void swap(date& other) noexcept {
        _NEFORCE swap(year_, other.year_);
        _NEFORCE swap(month_, other.month_);
        _NEFORCE swap(day_, other.day_);
    }
};
 

class NEFORCE_API time : public iobject<time>, public icommon<time> {
public:
    using time_type = int32_t; 
 
private:
    time_type hours_ = 0;   
    time_type minutes_ = 0; 
    time_type seconds_ = 0; 
 
public:
    constexpr time() noexcept = default;

    NEFORCE_CONSTEXPR20 ~time() = default;

    constexpr explicit time(const time_type hour, const time_type minute, const time_type second) noexcept {
        if (is_valid(hour, minute, second)) {
            hours_ = hour;
            minutes_ = minute;
            seconds_ = second;
        }
    }
 
    constexpr time(const time&) noexcept = default;
    constexpr time& operator=(const time&) noexcept = default;
    constexpr time(time&&) noexcept = default;
    constexpr time& operator=(time&&) noexcept = default;

    NEFORCE_NODISCARD constexpr time_type hours() const noexcept { return hours_; }

    NEFORCE_NODISCARD constexpr time_type minutes() const noexcept { return minutes_; }

    NEFORCE_NODISCARD constexpr time_type seconds() const noexcept { return seconds_; }

    static constexpr bool is_valid(time_type hour, time_type minute, time_type second) noexcept {
        return hour >= 0 && hour < 24 && minute >= 0 && minute < 60 && second >= 0 && second < 60;
    }

    NEFORCE_NODISCARD constexpr bool is_valid() const noexcept { return is_valid(hours_, minutes_, seconds_); }

    constexpr void clear() noexcept {
        hours_ = 0;
        minutes_ = 0;
        seconds_ = 0;
    }

    NEFORCE_NODISCARD constexpr time_type to_seconds() const noexcept {
        return hours_ * 3600 + minutes_ * 60 + seconds_;
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const time& other) const noexcept {
        return hours_ == other.hours_ && minutes_ == other.minutes_ && seconds_ == other.seconds_;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const time& other) const noexcept {
        if (hours_ < other.hours_) {
            return true;
        }
        if (hours_ == other.hours_) {
            if (minutes_ < other.minutes_) {
                return true;
            }
            if (minutes_ == other.minutes_ && seconds_ < other.seconds_) {
                return true;
            }
        }
        return false;
    }

    constexpr time& operator+=(const time_type seconds) {
        if (seconds < 0) {
            return *this -= -seconds;
        }
 
        seconds_ += seconds;
        const time_type extra_min = seconds_ / 60;
        seconds_ %= 60;
 
        minutes_ += extra_min;
        const time_type extra_hour = minutes_ / 60;
        minutes_ %= 60;
 
        hours_ += extra_hour;
        hours_ %= 24;
 
        return *this;
    }

    constexpr time& operator-=(const time_type seconds) noexcept {
        if (seconds < 0) {
            return *this += -seconds;
        }
 
        int64_t total_sec = to_seconds() - seconds;
        total_sec %= 86400;
        if (total_sec < 0) {
            total_sec += 86400;
        }
 
        hours_ = static_cast<time_type>(total_sec / 3600);
        minutes_ = static_cast<time_type>((total_sec % 3600) / 60);
        seconds_ = static_cast<time_type>(total_sec % 60);
        return *this;
    }

    constexpr time operator+(const time_type seconds) const noexcept {
        time ret(*this);
        ret += seconds;
        return ret;
    }

    constexpr time operator-(const time_type seconds) const noexcept {
        time ret(*this);
        ret -= seconds;
        return ret;
    }

    constexpr time& operator++() { return *this += 1; }

    constexpr time operator++(int) {
        const time ret(*this);
        *this += 1;
        return ret;
    }

    constexpr time& operator--() { return *this -= 1; }

    constexpr time operator--(int) {
        const time ret(*this);
        *this -= 1;
        return ret;
    }

    constexpr time_type operator-(const time& other) const noexcept {
        time_type sec_diff = (hours_ - other.hours_) * 3600;
        sec_diff += (minutes_ - other.minutes_) * 60;
        sec_diff += (seconds_ - other.seconds_);
        return sec_diff;
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept {
        constexpr hash<time_type> hasher;
        return hasher(hours()) ^ hasher(minutes()) ^ hasher(seconds());
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const {
        return _NEFORCE format("{:02d}:{:02d}:{:02d}", hours(), minutes(), seconds());
    }

    NEFORCE_NODISCARD static constexpr time parse(const string_view view) {
        if (view.size() != 8 || view[2] != ':' || view[5] != ':') {
            NEFORCE_THROW_EXCEPTION(value_exception("Wrong string formation."));
        }
        const time_type hour = integer32::parse(view.substr(0, 2)).value();
        const time_type minute = integer32::parse(view.substr(3, 2)).value();
        const time_type second = integer32::parse(view.substr(6, 2)).value();
        return time(hour, minute, second);
    }

    constexpr void swap(time& other) noexcept {
        _NEFORCE swap(hours_, other.hours_);
        _NEFORCE swap(minutes_, other.minutes_);
        _NEFORCE swap(seconds_, other.seconds_);
    }
};
 

class NEFORCE_API datetime : public iobject<datetime>, public icommon<datetime> {
public:
    using date_type = _NEFORCE date::date_type; 
    using time_type = _NEFORCE time::time_type; 
 
private:
    _NEFORCE date date_;         
    _NEFORCE time time_;         
    int64_t offset_seconds_ = 0; 
    bool has_timezone_ = false;  
 
private:
    static constexpr int months_to_int(const string_view view) {
        constexpr string_view months_string[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
        for (int i = 0; i < 12; ++i) {
            if (view == months_string[i]) {
                return i + 1;
            }
        }
        return 0;
    }
 
public:
    constexpr datetime() noexcept = default;
 
    NEFORCE_CONSTEXPR20 ~datetime() = default;
 
    constexpr datetime(const datetime&) noexcept = default;
    constexpr datetime& operator=(const datetime&) noexcept = default;
    constexpr datetime(datetime&&) noexcept = default;
    constexpr datetime& operator=(datetime&&) noexcept = default;

    constexpr explicit datetime(const date_type year, const date_type month, const date_type day, const time_type hour,
                                const time_type minute, const time_type second) noexcept :
    date_(year, month, day),
    time_(hour, minute, second) {}

    constexpr explicit datetime(const date_type year, const date_type month, const date_type day, const time_type hour,
                                const time_type minute, const time_type second, const int64_t offset) noexcept :
    date_(year, month, day),
    time_(hour, minute, second),
    offset_seconds_(offset),
    has_timezone_(true) {}

    constexpr explicit datetime(const _NEFORCE date& date, const _NEFORCE time& time) noexcept :
    date_(date),
    time_(time) {}

    constexpr explicit datetime(const _NEFORCE date& date, const _NEFORCE time& time, const int64_t offset) noexcept :
    date_(date),
    time_(time),
    offset_seconds_(offset),
    has_timezone_(true) {}

    constexpr explicit datetime(const _NEFORCE date& date) noexcept :
    date_(date) {}

    constexpr explicit datetime(const _NEFORCE time& time) noexcept :
    time_(time) {}

    constexpr explicit datetime(_NEFORCE date&& date) noexcept :
    date_(date) {
        date.clear();
    }

    constexpr explicit datetime(_NEFORCE time&& time) noexcept :
    time_(time) {
        time.clear();
    }

    constexpr explicit datetime(_NEFORCE date&& date, _NEFORCE time&& time) noexcept :
    date_(date),
    time_(time) {
        date.clear();
        time.clear();
    }

    constexpr explicit datetime(_NEFORCE date&& date, _NEFORCE time&& time, const int64_t offset) noexcept :
    date_(date),
    time_(time),
    offset_seconds_(offset),
    has_timezone_(true) {
        date.clear();
        time.clear();
    }

    NEFORCE_NODISCARD constexpr bool is_valid() const noexcept { return date_.is_valid() && time_.is_valid(); }

    constexpr datetime& operator=(const _NEFORCE date& date) noexcept {
        date_ = date;
        return *this;
    }

    constexpr datetime& operator=(_NEFORCE date&& date) noexcept {
        date_ = date;
        date.clear();
        return *this;
    }

    constexpr datetime& operator=(const _NEFORCE time& time) noexcept {
        time_ = time;
        return *this;
    }

    constexpr datetime& operator=(_NEFORCE time&& time) noexcept {
        time_ = time;
        time.clear();
        return *this;
    }

    NEFORCE_NODISCARD constexpr const _NEFORCE date& date() const noexcept { return date_; }

    NEFORCE_NODISCARD constexpr const _NEFORCE time& time() const noexcept { return time_; }

    NEFORCE_NODISCARD constexpr time_type hours() const noexcept { return time_.hours(); }

    NEFORCE_NODISCARD constexpr time_type minutes() const noexcept { return time_.minutes(); }

    NEFORCE_NODISCARD constexpr time_type seconds() const noexcept { return time_.seconds(); }

    NEFORCE_NODISCARD constexpr date_type year() const noexcept { return date_.year(); }

    NEFORCE_NODISCARD constexpr date_type month() const noexcept { return date_.month(); }

    NEFORCE_NODISCARD constexpr date_type day() const noexcept { return date_.day(); }

    NEFORCE_NODISCARD constexpr bool has_timezone() const noexcept { return has_timezone_; }

    NEFORCE_NODISCARD constexpr int64_t offset_seconds() const noexcept { return offset_seconds_; }

    NEFORCE_NODISCARD static constexpr datetime epoch() noexcept { return datetime{}; }

    NEFORCE_NODISCARD static datetime now() noexcept;

    constexpr void clear() noexcept {
        date_.clear();
        time_.clear();
        offset_seconds_ = 0;
        has_timezone_ = false;
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const datetime& other) const noexcept {
        return date_ == other.date_ && time_ == other.time_ && has_timezone_ == other.has_timezone_ &&
               offset_seconds_ == other.offset_seconds_;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const datetime& other) const noexcept {
        if (date_ < other.date_) {
            return true;
        } else if (date_ == other.date_) {
            if (time_ < other.time_) {
                return true;
            } else if (time_ == other.time_) {
                if (has_timezone_ && other.has_timezone_ && offset_seconds_ < other.offset_seconds_) {
                    return true;
                }
            }
        }
        return false;
    }

    constexpr datetime& operator+=(const int64_t seconds) {
        if (seconds < 0) {
            return *this -= -seconds;
        }
 
        const int64_t current_total_sec = static_cast<int64_t>(time_.hours()) * 3600 +
                                          static_cast<int64_t>(time_.minutes()) * 60 +
                                          static_cast<int64_t>(time_.seconds());
 
        int64_t new_total_sec = current_total_sec + seconds;
        int64_t days_to_add = new_total_sec / 86400;
        new_total_sec %= 86400;
 
        if (new_total_sec < 0) {
            new_total_sec += 86400;
            days_to_add--;
        }
 
        date_ += static_cast<date_type>(days_to_add);
        time_ = _NEFORCE time(static_cast<time_type>(new_total_sec / 3600),
                              static_cast<time_type>((new_total_sec % 3600) / 60),
                              static_cast<time_type>(new_total_sec % 60));
        return *this;
    }

    constexpr datetime& operator-=(const int64_t seconds) noexcept {
        if (seconds < 0) {
            return *this += -seconds;
        }
 
        const int64_t current_total_sec = static_cast<int64_t>(time_.hours()) * 3600 +
                                          static_cast<int64_t>(time_.minutes()) * 60 +
                                          static_cast<int64_t>(time_.seconds());
 
        int64_t new_total_sec = current_total_sec - seconds;
        int64_t days_to_subtract = 0;
 
        if (new_total_sec < 0) {
            days_to_subtract = (-new_total_sec + 86399) / 86400;
            new_total_sec += days_to_subtract * 86400;
        }
 
        date_ -= static_cast<date_type>(days_to_subtract);
        time_ = _NEFORCE time(static_cast<time_type>(new_total_sec / 3600),
                              static_cast<time_type>((new_total_sec % 3600) / 60),
                              static_cast<time_type>(new_total_sec % 60));
        return *this;
    }

    constexpr datetime operator+(const int64_t seconds) const noexcept {
        datetime ret(*this);
        ret += seconds;
        return ret;
    }

    constexpr datetime operator-(const int64_t seconds) const noexcept {
        datetime ret(*this);
        ret -= seconds;
        return ret;
    }

    constexpr datetime& operator++() { return *this += 1; }

    constexpr datetime operator++(int) {
        const datetime ret(*this);
        *this += 1;
        return ret;
    }

    constexpr datetime& operator--() { return *this -= 1; }

    constexpr datetime operator--(int) {
        const datetime ret(*this);
        *this -= 1;
        return ret;
    }

    constexpr time_type operator-(const datetime& other) const noexcept {
        const datetime lhs_utc = this->to_UTC();
        const datetime rhs_utc = other.to_UTC();
 
        const time_type day_diff = lhs_utc.date_ - rhs_utc.date_;
        time_type sec_diff = day_diff * 86400;
        sec_diff += (lhs_utc.time_ - rhs_utc.time_);
        return sec_diff;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_offset_string() const {
        if (!has_timezone_) {
            return {};
        }
        if (offset_seconds_ == 0) {
            return "Z";
        }
        int64_t total_sec = offset_seconds_;
        const char sign = total_sec >= 0 ? '+' : '-';
        total_sec = total_sec >= 0 ? total_sec : -total_sec;
        const int64_t hours = total_sec / 3600;
        const int64_t minutes = (total_sec % 3600) / 60;
        return sign + _NEFORCE format("{:02d}:{:02d}", hours, minutes);
    }

    static constexpr datetime from_UTC(const datetime& utc, const int32_t offset = 0) noexcept {
        datetime utc_time = utc;
        if (utc.has_timezone_ && utc.offset_seconds_ != 0) {
            utc_time = utc.to_UTC();
        }
        datetime local = utc_time + offset;
        local.offset_seconds_ = offset;
        local.has_timezone_ = true;
        return local;
    }

    NEFORCE_NODISCARD constexpr datetime to_UTC() const noexcept {
        if (!has_timezone_) {
            return *this;
        }
        datetime utc = *this;
        utc -= offset_seconds_;
        utc.offset_seconds_ = 0;
        utc.has_timezone_ = true;
        return utc;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_RFC3339() const {
        if (has_timezone_) {
            return date_.to_string() + "T" + time_.to_string() + to_offset_string();
        } else {
            return date_.to_string() + "T" + time_.to_string() + "Z";
        }
    }

    NEFORCE_NODISCARD static constexpr datetime parse_RFC3339(const string_view view) {
        if (view.size() < 20 || view[10] != 'T') {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 datetime format."));
        }
 
        const _NEFORCE date d = date::parse(view.substr(0, 10));
        const _NEFORCE time t = time::parse(view.substr(11, 8));
 
        if (view.size() == 19) {
            NEFORCE_THROW_EXCEPTION(value_exception("RFC3339 requires timezone offset (Z or ±HH:MM)."));
        }
 
        if (view.size() > 19 && view[19] == 'Z') {
            if (view.size() != 20) {
                NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 format: trailing characters after 'Z'."));
            }
            return datetime(d, t, 0);
        } else if (view.size() > 19 && (view[19] == '+' || view[19] == '-')) {
            if (view.size() != 25) {
                NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 timezone offset format."));
            }
            if (view[22] != ':') {
                NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 timezone offset format, expected ':'."));
            }
 
            const char sign = view[19];
            const int hours = integer32::parse(view.substr(20, 2)).value();
            const int minutes = integer32::parse(view.substr(23, 2)).value();
 
            if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
                NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 timezone offset values."));
            }
 
            int32_t total_offset = hours * 3600 + minutes * 60;
            if (sign == '-') {
                total_offset = -total_offset;
            }
            return datetime(d, t, total_offset);
        }
 
        NEFORCE_THROW_EXCEPTION(value_exception("Invalid RFC3339 datetime format."));
    }

    NEFORCE_CONSTEXPR20 bool try_parse_RFC3339(const string_view view) noexcept {
        try {
            datetime tmp = datetime::parse_RFC3339(view);
            this->swap(tmp);
        } catch (...) {
            return false;
        }
        return true;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_RFC1123() const {
        constexpr string_view months_string[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
        constexpr string_view weekdays_string[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 
        const _NEFORCE date utc_date = date();
        const _NEFORCE time utc_time = time();
 
        int wday = utc_date.days_of_week();
        if (wday < 0 || wday >= 7) {
            wday = 0;
        }
 
        int mon_idx = utc_date.month() - 1;
        if (mon_idx < 0 || mon_idx >= 12) {
            mon_idx = 0;
        }
 
        return _NEFORCE format("{}, {:02d} {} {} {} GMT", weekdays_string[wday], utc_date.day(), months_string[mon_idx],
                               utc_date.year(), utc_time.to_string());
    }

    NEFORCE_NODISCARD static constexpr datetime parse_RFC1123(string_view view) {
        if (view.size() < 29) {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid date length."));
        }
        if (view.substr(3, 2) != ", ") {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid date format"));
        }
 
        view.remove_prefix(5);
        const int day = integer32::parse(view.head(2)).value();
        view.remove_prefix(3);
        const int mon = months_to_int(view.head(3));
        if (mon == 0) {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid month in date"));
        }
        view.remove_prefix(4);
        const int year = integer32::parse(view.head(4)).value();
        view.remove_prefix(5);
        const int hour = integer32::parse(view.head(2)).value();
        view.remove_prefix(3);
        const int minute = integer32::parse(view.head(2)).value();
        view.remove_prefix(3);
        const int second = integer32::parse(view.head(2)).value();
        view.remove_prefix(3);
 
        if (view != "GMT") {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid timezone in date"));
        }
        return datetime(year, mon, day, hour, minute, second);
    }

    NEFORCE_CONSTEXPR20 bool try_parse_RFC1123(const string_view view) noexcept {
        try {
            datetime tmp = datetime::parse_RFC1123(view);
            this->swap(tmp);
        } catch (...) {
            return false;
        }
        return true;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_ISO8601() const {
        return date_.to_string() + "T" + time_.to_string();
    }

    NEFORCE_NODISCARD static constexpr datetime parse_ISO8601(const string_view view) {
        if (view.size() < 19 || view[10] != 'T') {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid ISO 8601 datetime format."));
        }
        const _NEFORCE date d = _NEFORCE date::parse(view.substr(0, 10));
        size_t time_len = 8;
        if (view.size() >= 19) {
            time_len = 8;
        }
        const _NEFORCE time t = _NEFORCE time::parse(view.substr(11, time_len));
        return datetime(d, t);
    }

    NEFORCE_CONSTEXPR20 bool try_parse_ISO8601(const string_view view) noexcept {
        try {
            datetime tmp = datetime::parse_ISO8601(view);
            this->swap(tmp);
        } catch (...) {
            return false;
        }
        return true;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const {
        return date_.to_string() + " " + time_.to_string();
    }

    NEFORCE_NODISCARD static constexpr datetime parse(const string_view view) {
        if (view.size() != 19 || view[10] != ' ') {
            NEFORCE_THROW_EXCEPTION(value_exception("Wrong string formation."));
        }
        const _NEFORCE date d = date::parse(view.substr(0, 10));
        const _NEFORCE time t = time::parse(view.substr(11, 8));
        return datetime(d, t);
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept {
        return date_.to_hash() ^ time_.to_hash() ^ hash<bool>()(has_timezone_) ^ hash<int64_t>()(offset_seconds_);
    }

    constexpr void swap(datetime& other) noexcept {
        _NEFORCE swap(date_, other.date_);
        _NEFORCE swap(time_, other.time_);
        _NEFORCE swap(offset_seconds_, other.offset_seconds_);
        _NEFORCE swap(has_timezone_, other.has_timezone_);
    }
};
 

class NEFORCE_API timestamp : public iobject<timestamp>, public ipackage<timestamp, int64_t> {
public:
    using value_type = int64_t; 
 
    constexpr timestamp() noexcept = default;
 
    NEFORCE_CONSTEXPR20 ~timestamp() = default;
 
    constexpr timestamp(const timestamp& other) noexcept :
    ipackage(other.value_) {}
 
    constexpr timestamp& operator=(const timestamp& other) noexcept {
        value_ = other.value_;
        return *this;
    }
 
    constexpr timestamp(timestamp&& other) noexcept :
    ipackage(other.value_) {
        other.clear();
    }
 
    constexpr timestamp& operator=(timestamp&& other) noexcept {
        value_ = other.value_;
        other.clear();
        return *this;
    }

    constexpr explicit timestamp(const value_type value) noexcept :
    ipackage(value) {}

    constexpr explicit timestamp(const datetime& dt) noexcept {
        const datetime utc = dt.to_UTC();
        value_ = utc - datetime::epoch().to_UTC();
    }

    NEFORCE_NODISCARD static timestamp now() noexcept { return timestamp(datetime::now()); }

    NEFORCE_NODISCARD constexpr datetime to_datetime() const noexcept { return datetime::epoch() + value_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const { return integer64(value_).to_string(); }

    NEFORCE_NODISCARD static constexpr timestamp parse(const string_view view) {
        return timestamp{integer64::parse(view).value()};
    }

    constexpr void clear() noexcept { value_ = 0; }
};
 // DateTime
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_TIME_DATETIME_HPP__