date_time_conversions.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef TIME_SHIELD_HEADER_CONVERSIONS_DATE_TIME_CONVERSIONS_HPP_INCLUDED
#define TIME_SHIELD_HEADER_CONVERSIONS_DATE_TIME_CONVERSIONS_HPP_INCLUDED
 
 
#include <time_shield/core.hpp>
#include "date_conversions.hpp"
#include "detail/fast_date.hpp"
#include "detail/floor_math.hpp"
#include "time_unit_conversions.hpp"
#include "unix_time_conversions.hpp"
 
#include <cmath>
#include <ctime>
#include <limits>
#include <stdexcept>
#include <type_traits>
 
namespace time_shield {
 
 
    namespace legacy {
 
        template<class T1 = DateTimeStruct, class T2 = ts_t>
        T1 to_date_time(T2 ts) {
            // 9223372029693630000 reaches year 292277024400 from the 2000 epoch.
            // This value overflows the n_400_years * SEC_PER_400_YEARS calculation.
            // The supported bound is reduced to 9223371890843040000.
            constexpr int64_t BIAS_292277022000 = 9223371890843040000LL;
            constexpr int64_t BIAS_2000 = 946684800LL;
 
            int64_t y = MAX_YEAR;
            int64_t secs = -((static_cast<int64_t>(ts) - BIAS_2000) - BIAS_292277022000);
 
            const int64_t n_400_years = secs / SEC_PER_400_YEARS;
            secs -= n_400_years * SEC_PER_400_YEARS;
            y -= n_400_years * 400LL;
 
            const int64_t n_100_years = secs / SEC_PER_100_YEARS;
            secs -= n_100_years * SEC_PER_100_YEARS;
            y -= n_100_years * 100LL;
 
            const int64_t n_4_years = secs / SEC_PER_4_YEARS;
            secs -= n_4_years * SEC_PER_4_YEARS;
            y -= n_4_years * 4LL;
 
            const int64_t n_1_years = secs / SEC_PER_YEAR;
            secs -= n_1_years * SEC_PER_YEAR;
            y -= n_1_years;
 
            T1 date_time;
 
            if (secs == 0) {
                date_time.year = y;
                date_time.mon = 1;
                date_time.day = 1;
                return date_time;
            }
 
            date_time.year = y - 1;
            const bool is_leap_year = is_leap_year_date(date_time.year);
            secs = is_leap_year ? SEC_PER_LEAP_YEAR - secs : SEC_PER_YEAR - secs;
            const int days = static_cast<int>(secs / SEC_PER_DAY);
 
            constexpr int JAN_AND_FEB_DAY_LEAP_YEAR = 60 - 1;
            constexpr int TABLE_MONTH_OF_YEAR[] = {
                1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // January (31 days)
                2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,        // February (28 days)
                3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,  // March (31 days)
                4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,    // April (30 days)
                5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
                6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
                7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
                8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
                9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
                10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
                11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
                12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
            };
            constexpr int TABLE_DAY_OF_YEAR[] = {
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,    // January (31 days)
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,             // February (28 days)
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,    // March (31 days)
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,       // April (30 days)
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
            };
 
            if (is_leap_year) {
                const int prev_days = days - 1;
                date_time.day = days == JAN_AND_FEB_DAY_LEAP_YEAR ? (TABLE_DAY_OF_YEAR[prev_days] + 1) :
                    (days > JAN_AND_FEB_DAY_LEAP_YEAR ? TABLE_DAY_OF_YEAR[prev_days] : TABLE_DAY_OF_YEAR[days]);
                date_time.mon = days >= JAN_AND_FEB_DAY_LEAP_YEAR ? TABLE_MONTH_OF_YEAR[prev_days] : TABLE_MONTH_OF_YEAR[days];
            } else {
                date_time.day = TABLE_DAY_OF_YEAR[days];
                date_time.mon = TABLE_MONTH_OF_YEAR[days];
            }
 
            ts_t day_secs = static_cast<ts_t>(detail::floor_mod(secs, SEC_PER_DAY));
            date_time.hour = static_cast<decltype(date_time.hour)>(day_secs / SEC_PER_HOUR);
            ts_t min_secs = static_cast<ts_t>(day_secs - date_time.hour * SEC_PER_HOUR);
            date_time.min = static_cast<decltype(date_time.min)>(min_secs / SEC_PER_MIN);
            date_time.sec = static_cast<decltype(date_time.sec)>(min_secs - date_time.min * SEC_PER_MIN);
#           ifdef TIME_SHIELD_CPP17
            if TIME_SHIELD_IF_CONSTEXPR (std::is_floating_point<T2>::value) {
                date_time.ms = static_cast<int>(std::round(std::fmod(static_cast<double>(ts), static_cast<double>(MS_PER_SEC))));
            } else date_time.ms = 0;
#           else
            if (std::is_floating_point<T2>::value) {
                date_time.ms = static_cast<int>(std::round(std::fmod(static_cast<double>(ts), static_cast<double>(MS_PER_SEC))));
            } else date_time.ms = 0;
#           endif
            return date_time;
        }
 
    } // namespace legacy
 
    template<class T1 = DateTimeStruct, class T2 = ts_t>
    T1 to_date_time(T2 ts) {
        const int64_t whole_sec = static_cast<int64_t>(ts);
        const detail::DaySplit split = detail::split_unix_day(whole_sec);
        const detail::FastDate date = detail::fast_date_from_days(split.days);
 
        T1 date_time{};
        date_time.year = static_cast<decltype(date_time.year)>(date.year);
        date_time.mon = static_cast<decltype(date_time.mon)>(date.month);
        date_time.day = static_cast<decltype(date_time.day)>(date.day);
 
        const ts_t day_secs = static_cast<ts_t>(split.sec_of_day);
        date_time.hour = static_cast<decltype(date_time.hour)>(day_secs / SEC_PER_HOUR);
        const ts_t min_secs = static_cast<ts_t>(day_secs - date_time.hour * SEC_PER_HOUR);
        date_time.min = static_cast<decltype(date_time.min)>(min_secs / SEC_PER_MIN);
        date_time.sec = static_cast<decltype(date_time.sec)>(min_secs - date_time.min * SEC_PER_MIN);
#       ifdef TIME_SHIELD_CPP17
        if TIME_SHIELD_IF_CONSTEXPR (std::is_floating_point<T2>::value) {
            date_time.ms = static_cast<int>(std::round(std::fmod(static_cast<double>(ts), static_cast<double>(MS_PER_SEC))));
        } else date_time.ms = 0;
#       else
        if (std::is_floating_point<T2>::value) {
            date_time.ms = static_cast<int>(std::round(std::fmod(static_cast<double>(ts), static_cast<double>(MS_PER_SEC))));
        } else date_time.ms = 0;
#       endif
        return date_time;
    }
 
    template<class T>
    inline T to_date_time_ms(ts_ms_t ts) {
        const ts_t sec = ms_to_sec<ts_t, ts_ms_t>(ts);
        T date_time = to_date_time<T, ts_t>(sec);
        date_time.ms = ms_of_ts(ts); // Extract and set the ms component
        return date_time;
    }
 
    namespace legacy {
 
        template<class T1 = year_t, class T2 = int>
        TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp(
                T1 year,
                T2 month,
                T2 day,
                T2 hour  = 0,
                T2 min   = 0,
                T2 sec   = 0) {
 
            if (day >= UNIX_EPOCH && year <= 31) {
                return to_timestamp((T1)day, month, (T2)year, hour, min, sec);
            }
            if (!is_valid_date_time(year, month, day, hour, min, sec)) {
                throw std::invalid_argument("Invalid date-time combination");
            }
 
            int64_t secs = 0;
            int64_t years = (static_cast<int64_t>(MAX_YEAR) - year);
 
            const int64_t n_400_years = years / 400LL;
            secs += n_400_years * SEC_PER_400_YEARS;
            years -= n_400_years * 400LL;
 
            const int64_t n_100_years = years / 100LL;
            secs += n_100_years * SEC_PER_100_YEARS;
            years -= n_100_years * 100LL;
 
            const int64_t n_4_years = years / 4LL;
            secs += n_4_years * SEC_PER_4_YEARS;
            years -= n_4_years * 4LL;
 
            secs += years * SEC_PER_YEAR;
 
            // 9223372029693630000 reaches year 292277024400 from the 2000 epoch.
            // This value overflows the n_400_years * SEC_PER_400_YEARS calculation.
            // The supported bound is reduced to 9223371890843040000.
            constexpr int64_t BIAS_292277022000 = 9223371890843040000LL;
            constexpr int64_t BIAS_2000 = 946684800LL;
 
            secs = BIAS_292277022000 - secs;
            secs += BIAS_2000;
 
            if (month == 1 && day == 1 &&
                hour == 0 && min == 0 &&
                sec == 0) {
                return secs;
            }
 
            constexpr int lmos[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
            constexpr int mos[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
            secs += (is_leap_year_date(year) ? (lmos[month - 1] + day - 1) : (mos[month - 1] + day - 1)) * SEC_PER_DAY;
            secs += SEC_PER_HOUR * hour + SEC_PER_MIN * min + sec;
            return secs;
        }
 
        template<class T1 = year_t, class T2 = int>
        TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp_unchecked(
                T1 year,
                T2 month,
                T2 day,
                T2 hour  = 0,
                T2 min   = 0,
                T2 sec   = 0) noexcept {
 
            if (day >= UNIX_EPOCH && year <= 31) {
                return to_timestamp_unchecked((T1)day, month, (T2)year, hour, min, sec);
            }
 
            int64_t secs = 0;
            int64_t years = (static_cast<int64_t>(MAX_YEAR) - year);
 
            const int64_t n_400_years = years / 400LL;
            secs += n_400_years * SEC_PER_400_YEARS;
            years -= n_400_years * 400LL;
 
            const int64_t n_100_years = years / 100LL;
            secs += n_100_years * SEC_PER_100_YEARS;
            years -= n_100_years * 100LL;
 
            const int64_t n_4_years = years / 4LL;
            secs += n_4_years * SEC_PER_4_YEARS;
            years -= n_4_years * 4LL;
 
            secs += years * SEC_PER_YEAR;
 
            // 9223372029693630000 reaches year 292277024400 from the 2000 epoch.
            // This value overflows the n_400_years * SEC_PER_400_YEARS calculation.
            // The supported bound is reduced to 9223371890843040000.
            constexpr int64_t BIAS_292277022000 = 9223371890843040000LL;
            constexpr int64_t BIAS_2000 = 946684800LL;
 
            secs = BIAS_292277022000 - secs;
            secs += BIAS_2000;
 
            if (month == 1 && day == 1 &&
                hour == 0 && min == 0 &&
                sec == 0) {
                return secs;
            }
 
            constexpr int lmos[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
            constexpr int mos[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
            secs += (is_leap_year_date(year) ? (lmos[month - 1] + day - 1) : (mos[month - 1] + day - 1)) * SEC_PER_DAY;
            secs += SEC_PER_HOUR * hour + SEC_PER_MIN * min + sec;
            return secs;
        }
 
    } // namespace legacy
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp_unchecked(
            T1 year,
            T2 month,
            T2 day,
            T2 hour  = 0,
            T2 min   = 0,
            T2 sec   = 0) noexcept {
 
        if (day >= UNIX_EPOCH && year <= 31) {
            return to_timestamp_unchecked((T1)day, month, (T2)year, hour, min, sec);
        }
 
        const dse_t unix_day = date_to_unix_day(year, month, day);
        return static_cast<ts_t>(unix_day * SEC_PER_DAY
            + SEC_PER_HOUR * static_cast<int64_t>(hour)
            + SEC_PER_MIN * static_cast<int64_t>(min)
            + static_cast<int64_t>(sec));
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp(
            T1 year,
            T2 month,
            T2 day,
            T2 hour  = 0,
            T2 min   = 0,
            T2 sec   = 0) {
 
        if (day >= UNIX_EPOCH && year <= 31) {
            return to_timestamp((T1)day, month, (T2)year, hour, min, sec);
        }
        if (!is_valid_date_time(year, month, day, hour, min, sec)) {
            throw std::invalid_argument("Invalid date-time combination");
        }
 
        return to_timestamp_unchecked(year, month, day, hour, min, sec);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t dt_to_timestamp(
            const T& date_time) {
        return to_timestamp(
            date_time.year,
            date_time.mon,
            date_time.day,
            date_time.hour,
            date_time.min,
            date_time.sec
        );
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t tm_to_timestamp(
            const std::tm *timeinfo) {
        return to_timestamp(
            static_cast<year_t>(timeinfo->tm_year + 1900),
            static_cast<int>(timeinfo->tm_mon + 1),
            static_cast<int>(timeinfo->tm_mday),
            static_cast<int>(timeinfo->tm_hour),
            static_cast<int>(timeinfo->tm_min),
            static_cast<int>(timeinfo->tm_sec)
        );
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_timestamp_ms(
            T1 year,
            T2 month,
            T2 day,
            T2 hour = 0,
            T2 min  = 0,
            T2 sec  = 0,
            T2 ms   = 0) {
        int64_t sec_value = static_cast<int64_t>(to_timestamp<T1, T2>(year, month, day, hour, min, sec));
        int64_t ms_value = static_cast<int64_t>(ms);
        sec_value += detail::floor_div(ms_value, static_cast<int64_t>(MS_PER_SEC));
        ms_value = detail::floor_mod(ms_value, static_cast<int64_t>(MS_PER_SEC));
        if ((sec_value > 0 &&
             sec_value > ((std::numeric_limits<int64_t>::max)() - ms_value) / MS_PER_SEC) ||
            (sec_value < 0 &&
             sec_value < (std::numeric_limits<int64_t>::min)() / MS_PER_SEC)) {
            return ERROR_TIMESTAMP;
        }
        return static_cast<ts_ms_t>(sec_value * MS_PER_SEC + ms_value);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t dt_to_timestamp_ms(
            const T& date_time) {
        int64_t sec_value = static_cast<int64_t>(dt_to_timestamp(date_time));
        int64_t ms_value = static_cast<int64_t>(date_time.ms);
        sec_value += detail::floor_div(ms_value, static_cast<int64_t>(MS_PER_SEC));
        ms_value = detail::floor_mod(ms_value, static_cast<int64_t>(MS_PER_SEC));
        if ((sec_value > 0 &&
             sec_value > ((std::numeric_limits<int64_t>::max)() - ms_value) / MS_PER_SEC) ||
            (sec_value < 0 &&
             sec_value < (std::numeric_limits<int64_t>::min)() / MS_PER_SEC)) {
            return ERROR_TIMESTAMP;
        }
        return static_cast<ts_ms_t>(sec_value * MS_PER_SEC + ms_value);
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t tm_to_timestamp_ms(
            const std::tm *timeinfo) {
        return sec_to_ms(tm_to_timestamp(timeinfo));
    }
 
    template<class T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline fts_t to_ftimestamp(
            T1 year,
            T2 month,
            T2 day,
            T2 hour  = 0,
            T2 min   = 0,
            T2 sec   = 0,
            T3 ms    = 0) {
        int64_t sec_value = static_cast<int64_t>(to_timestamp(year, month, day, hour, min, sec));
        int64_t ms_value = static_cast<int64_t>(ms);
        sec_value += detail::floor_div(ms_value, static_cast<int64_t>(MS_PER_SEC));
        ms_value = detail::floor_mod(ms_value, static_cast<int64_t>(MS_PER_SEC));
        return static_cast<fts_t>(sec_value) +
            static_cast<fts_t>(ms_value) / static_cast<fts_t>(MS_PER_SEC);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline fts_t dt_to_ftimestamp(
            const T& date_time) {
        int64_t sec_value = static_cast<int64_t>(to_timestamp(date_time));
        int64_t ms_value = static_cast<int64_t>(date_time.ms);
        sec_value += detail::floor_div(ms_value, static_cast<int64_t>(MS_PER_SEC));
        ms_value = detail::floor_mod(ms_value, static_cast<int64_t>(MS_PER_SEC));
        return static_cast<fts_t>(sec_value) +
            static_cast<fts_t>(ms_value) / static_cast<fts_t>(MS_PER_SEC);
    }
 
    TIME_SHIELD_CONSTEXPR inline fts_t tm_to_ftimestamp(
            const std::tm* timeinfo) {
        return static_cast<fts_t>(tm_to_timestamp(timeinfo));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_DAY);
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_t start_of_prev_day(ts_t ts = time_shield::ts(), T days = 1) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_DAY) - SEC_PER_DAY * days;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_day_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_day(ms_to_sec<ts_t>(ts_ms));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_day_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - detail::floor_mod(ts_ms, MS_PER_DAY);
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_t start_of_next_day(ts_t ts, T days = 1) noexcept {
        return start_of_day(ts) + days * SEC_PER_DAY;
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_ms_t start_of_next_day_ms(ts_ms_t ts_ms, T days = 1) noexcept {
        return start_of_day_ms(ts_ms) + days * MS_PER_DAY;
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_t next_day(ts_t ts, T days = 1) noexcept {
        return ts + days * SEC_PER_DAY;
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_ms_t next_day_ms(ts_ms_t ts_ms, T days = 1) noexcept {
        return ts_ms + days * MS_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_DAY) + SEC_PER_DAY - 1;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_day_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_day(ms_to_sec<ts_t>(ts_ms));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_ms_t end_of_day_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - detail::floor_mod(ts_ms, MS_PER_DAY) + MS_PER_DAY - 1;
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year_date(T year) {
        const ts_t year_ts = to_timestamp(year, 1, 1);
 
        return start_of_day(year_ts);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_year_date_ms(T year) {
        return sec_to_ms(start_of_year_date(year));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year(ts_t ts) noexcept {
        constexpr ts_t BIAS_2100 = 4102444800;
        if (ts >= 0 && ts < BIAS_2100) {
            constexpr ts_t SEC_PER_YEAR_X2 = SEC_PER_YEAR * 2;
            ts_t year_start_ts = detail::floor_mod(ts, SEC_PER_4_YEARS);
            if (year_start_ts < SEC_PER_YEAR) {
                return ts - year_start_ts;
            } else if (year_start_ts < SEC_PER_YEAR_X2) {
                return ts + SEC_PER_YEAR - year_start_ts;
            } else if (year_start_ts < (SEC_PER_YEAR_X2 + SEC_PER_LEAP_YEAR)) {
                return ts + SEC_PER_YEAR_X2 - year_start_ts;
            }
            return ts + (SEC_PER_YEAR_X2 + SEC_PER_LEAP_YEAR) - year_start_ts;
        }
 
        constexpr ts_t BIAS_2000 = 946684800;
        ts_t secs = ts - BIAS_2000;
 
        ts_t offset_y400 = detail::floor_mod(secs, SEC_PER_400_YEARS);
        ts_t start_ts = secs - offset_y400 + BIAS_2000;
        secs = offset_y400;
 
        if (secs >= SEC_PER_FIRST_100_YEARS) {
            secs -= SEC_PER_FIRST_100_YEARS;
            start_ts += SEC_PER_FIRST_100_YEARS;
            while (secs >= SEC_PER_100_YEARS) {
                secs -= SEC_PER_100_YEARS;
                start_ts += SEC_PER_100_YEARS;
            }
 
            constexpr ts_t SEC_PER_4_YEARS_V2 = 4 * SEC_PER_YEAR;
            if (secs >= SEC_PER_4_YEARS_V2) {
                secs -= SEC_PER_4_YEARS_V2;
                start_ts += SEC_PER_4_YEARS_V2;
            } else {
                start_ts += secs - detail::floor_mod(secs, SEC_PER_YEAR);
                return start_ts;
            }
        }
 
        ts_t offset_4y = detail::floor_mod(secs, SEC_PER_4_YEARS);
        start_ts += secs - offset_4y;
        secs = offset_4y;
 
        if (secs >= SEC_PER_LEAP_YEAR) {
            secs -= SEC_PER_LEAP_YEAR;
            start_ts += SEC_PER_LEAP_YEAR;
            start_ts += secs - detail::floor_mod(secs, SEC_PER_YEAR);
            return start_ts;
        }
 
        start_ts += secs - detail::floor_mod(secs, SEC_PER_YEAR);
        return start_ts;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return sec_to_ms(start_of_year(ms_to_sec<ts_t>(ts_ms)));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_year(ts_t ts = time_shield::ts()) {
        const ts_t year_start = start_of_year(ts);
        const ts_t year_days = static_cast<ts_t>(num_days_in_year_ts(ts));
        return year_start + year_days * SEC_PER_DAY - 1;
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t end_of_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return sec_to_ms(end_of_year(ms_to_sec<ts_t>(ts_ms))) + (MS_PER_SEC - 1);
    }
 
    template<class T = int>
    inline T day_of_year(ts_t ts = time_shield::ts()) {
        return  static_cast<T>(((ts - start_of_year(ts)) / SEC_PER_DAY) + 1);
    }
 
    template<class T = Month>
    TIME_SHIELD_CONSTEXPR inline T month_of_year(ts_t ts) noexcept {
        constexpr int JAN_AND_FEB_DAY_LEAP_YEAR = 60;
        constexpr int TABLE_MONTH_OF_YEAR[] = {
            0,
            1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // January (31 days)
            2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,        // February (28 days)
            3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,  // March (31 days)
            4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,    // April (30 days)
            5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
            6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
            7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
            8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
            9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
            10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
            11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
            12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
        };
        const size_t dy = day_of_year<size_t>(ts);
        return static_cast<T>((is_leap_year(ts) && dy >= JAN_AND_FEB_DAY_LEAP_YEAR) ? TABLE_MONTH_OF_YEAR[dy - 1] : TABLE_MONTH_OF_YEAR[dy]);
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline T day_of_month(ts_t ts = time_shield::ts()) {
        constexpr int JAN_AND_FEB_DAY_LEAP_YEAR = 60;
        // Month numbers for a common year.
        constexpr int TABLE_DAY_OF_YEAR[] = {
            0,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,    // January (31 days)
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,             // February (28 days)
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,    // March (31 days)
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,       // April (30 days)
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
            1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
        };
        const size_t dy = day_of_year<size_t>(ts);
        if(is_leap_year(ts)) {
            if(dy == JAN_AND_FEB_DAY_LEAP_YEAR) return TABLE_DAY_OF_YEAR[dy - 1] + 1;
            if(dy > JAN_AND_FEB_DAY_LEAP_YEAR) return TABLE_DAY_OF_YEAR[dy - 1];
        }
        return TABLE_DAY_OF_YEAR[dy];
    }
 
    template<class T1 = int, class T2 = year_t, class T3 = int>
    TIME_SHIELD_CONSTEXPR T1 num_days_in_month(T2 year, T3 month) noexcept {
        constexpr T1 num_days[13] = {0,31,30,31,30,31,30,31,31,30,31,30,31};
        return (month > MONTHS_PER_YEAR || month < 0)
            ? static_cast<T1>(0)
            : (month == FEB ? static_cast<T1>(is_leap_year_date(year) ? 29 : 28) : num_days[month]);
    }
 
    template<class T1 = int>
    TIME_SHIELD_CONSTEXPR T1 num_days_in_month_ts(ts_t ts = time_shield::ts()) noexcept {
        constexpr T1 num_days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        const int month = month_of_year<int>(ts);
        if (month == FEB) {
            return is_leap_year(ts) ? 29 : 28;
        }
        return num_days[month];
    }
 
    template<class T = Weekday>
    TIME_SHIELD_CONSTEXPR T weekday_of_ts(ts_t ts) noexcept {
        const ts_t days = detail::floor_div(ts, SEC_PER_DAY);
        return static_cast<T>(detail::floor_mod(days + THU, DAYS_PER_WEEK));
    }
 
    template<class T = Weekday>
    TIME_SHIELD_CONSTEXPR T weekday_of_ts_ms(ts_ms_t ts_ms) {
        return weekday_of_ts<T>(ms_to_sec<ts_t>(ts_ms));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_month(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) - (day_of_month(ts) - 1) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_month(ts_t ts = time_shield::ts()) {
        return end_of_day(ts) + (num_days_in_month_ts(ts) - day_of_month(ts)) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t last_sunday_of_month(ts_t ts = time_shield::ts()) {
        const ts_t month_end = end_of_month(ts);
        return start_of_day(month_end) - weekday_of_ts(month_end) * SEC_PER_DAY;
    }
 
    template<class T1 = int, class T2 = year_t, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline T1 last_sunday_month_day(T2 year, T3 month) {
        const T1 days = num_days_in_month(year, month);
        return days - day_of_week_date(year, month, days);
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_week(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) - weekday_of_ts(ts) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_week(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) + (DAYS_PER_WEEK - weekday_of_ts(ts)) * SEC_PER_DAY - 1;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_saturday(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) + (SAT - weekday_of_ts(ts)) * SEC_PER_DAY;
    }
 
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_HOUR);
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_hour_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_hour(ms_to_sec<ts_t>(ts_ms));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_hour_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - detail::floor_mod(ts_ms, MS_PER_HOUR);
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_HOUR) + SEC_PER_HOUR - 1;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_hour_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_hour(ms_to_sec<ts_t>(ts_ms));
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_ms_t end_of_hour_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - detail::floor_mod(ts_ms, MS_PER_HOUR) + MS_PER_HOUR - 1;
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_min(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_MIN);
    }
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_min(ts_t ts = time_shield::ts()) noexcept {
        return ts - detail::floor_mod(ts, SEC_PER_MIN) + SEC_PER_MIN - 1;
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR T min_of_day(ts_t ts = time_shield::ts()) noexcept {
        const ts_t minutes = detail::floor_div(ts, SEC_PER_MIN);
        return static_cast<T>(detail::floor_mod(minutes, MIN_PER_DAY));
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR T hour_of_day(ts_t ts = time_shield::ts()) noexcept {
        const ts_t hours = detail::floor_div(ts, SEC_PER_HOUR);
        return static_cast<T>(detail::floor_mod(hours, HOURS_PER_DAY));
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR T min_of_hour(ts_t ts = time_shield::ts()) noexcept {
        const ts_t minutes = detail::floor_div(ts, SEC_PER_MIN);
        return static_cast<T>(detail::floor_mod(minutes, MIN_PER_HOUR));
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_t start_of_period(T p, ts_t ts = time_shield::ts()) {
        const ts_t period = static_cast<ts_t>(p);
        return period <= 0 ? ERROR_TIMESTAMP : ts - detail::floor_mod(ts, period);
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR ts_t end_of_period(T p, ts_t ts = time_shield::ts()) {
        const ts_t period = static_cast<ts_t>(p);
        return period <= 0 ? ERROR_TIMESTAMP : ts - detail::floor_mod(ts, period) + period - 1;
    }
 
 
}; // namespace time_shield
 
#endif // TIME_SHIELD_HEADER_CONVERSIONS_DATE_TIME_CONVERSIONS_HPP_INCLUDED