time_conversions.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef _TIME_SHIELD_TIME_CONVERSIONS_HPP_INCLUDED
#define _TIME_SHIELD_TIME_CONVERSIONS_HPP_INCLUDED

 
#include "enums.hpp"
#include "validation.hpp"
#include "time_utils.hpp"
#include "time_zone_struct.hpp"
#include "date_time_struct.hpp"
#include <cmath>
#include <ctime>
#include <stdexcept>
 
namespace time_shield {


    template<class T = int>
    constexpr T ns_of_sec(fts_t ts) noexcept {
        fts_t temp;
        return static_cast<T>(std::round(std::modf(ts, &temp) * static_cast<fts_t>(NS_PER_SEC)));
    }

    template<class T = int>
    constexpr T us_of_sec(fts_t ts) noexcept {
        fts_t temp;
        return static_cast<T>(std::round(std::modf(ts, &temp) * static_cast<fts_t>(US_PER_SEC)));
    }

    template<class T = int>
    constexpr T ms_of_sec(fts_t ts) noexcept {
        fts_t temp;
        return static_cast<T>(std::round(std::modf(ts, &temp) * static_cast<fts_t>(MS_PER_SEC)));
    }

    template<class T = int>
    constexpr T ms_of_ts(ts_ms_t ts) noexcept {
        return ts % MS_PER_SEC;
    }
 
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr ts_ms_t sec_to_ms_impl(T t, std::true_type tag) noexcept {
        return static_cast<ts_ms_t>(std::round(t * static_cast<T>(MS_PER_SEC)));
    }

    template<class T>
    constexpr ts_ms_t sec_to_ms_impl(T t, std::false_type tag) noexcept {
        return static_cast<ts_ms_t>(t) * static_cast<ts_ms_t>(MS_PER_SEC);
    }
#   endif // TIME_SHIELD_CPP17

    template<class T1 = ts_ms_t, class T2>
    constexpr T1 sec_to_ms(T2 ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr (std::is_floating_point_v<T2>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(MS_PER_SEC)));
        } else {
            return static_cast<T1>(ts) * static_cast<T1>(MS_PER_SEC);
        }
#       else
        return sec_to_ms_impl(ts, typename std::conditional<
            (std::is_same<T2, double>::value || std::is_same<T2, float>::value),
            std::true_type,
            std::false_type
        >::type{});
#       endif
    }

    inline ts_ms_t fsec_to_ms(fts_t ts) noexcept {
        return static_cast<ts_ms_t>(std::round(ts * static_cast<fts_t>(MS_PER_SEC)));
    }

    template<class T1 = ts_t, class T2 = ts_ms_t>
    constexpr T1 ms_to_sec(T2 ts_ms) noexcept {
        return static_cast<T1>(ts_ms) / static_cast<T1>(MS_PER_SEC);
    }

    template<class T = ts_ms_t>
    constexpr fts_t ms_to_fsec(T ts_ms) noexcept {
        return static_cast<fts_t>(ts_ms) / static_cast<fts_t>(MS_PER_SEC);
    }
 
//----------------------------------------------------------------------------//
// Minutes -> Milliseconds
//----------------------------------------------------------------------------//
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr ts_ms_t min_to_ms_impl(T t, std::true_type tag) noexcept {
        return static_cast<ts_ms_t>(std::round(t * static_cast<T>(MS_PER_MIN)));
    }

    template<class T>
    constexpr ts_ms_t min_to_ms_impl(T t, std::false_type tag) noexcept {
        return static_cast<ts_ms_t>(t) * static_cast<ts_ms_t>(MS_PER_MIN);
    }
#   endif // TIME_SHIELD_CPP17

    template<class T1 = ts_ms_t, class T2>
    constexpr T1 min_to_ms(T2 ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr (std::is_floating_point_v<T2>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(MS_PER_MIN)));
        } else {
            return static_cast<T1>(ts) * static_cast<T1>(MS_PER_MIN);
        }
#       else
        return min_to_ms_impl(ts, typename std::conditional<
            (std::is_same<T2, double>::value || std::is_same<T2, float>::value),
            std::true_type,
            std::false_type
        >::type{});
#       endif
    }

    template<class T1 = int, class T2 = ts_ms_t>
    constexpr T1 ms_to_min(T2 ts) noexcept {
        return static_cast<T1>(ts) / static_cast<T1>(MS_PER_MIN);
    }
 
//----------------------------------------------------------------------------//
// Minutes -> Seconds
//----------------------------------------------------------------------------//
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr ts_t min_to_sec_impl(T t, std::true_type tag) noexcept {
        return static_cast<ts_t>(std::round(t * static_cast<T>(SEC_PER_MIN)));
    }

    template<class T>
    constexpr ts_t min_to_sec_impl(T t, std::false_type tag) noexcept {
        return static_cast<ts_t>(t) * static_cast<ts_t>(SEC_PER_MIN);
    }
#   endif // TIME_SHIELD_CPP17

    template<class T1 = ts_t, class T2>
    constexpr T1 min_to_sec(T2 ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr (std::is_floating_point_v<T2>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(SEC_PER_MIN)));
        } else {
            return static_cast<T1>(ts) * static_cast<T1>(SEC_PER_MIN);
        }
#       else
        return min_to_sec_impl(ts, typename std::conditional<
            (std::is_same<T2, double>::value || std::is_same<T2, float>::value),
            std::true_type,
            std::false_type
        >::type{});
#       endif
    }

    template<class T1 = int, class T2 = ts_t>
    constexpr T1 sec_to_min(T2 ts) noexcept {
        return static_cast<T1>(ts) / static_cast<T1>(SEC_PER_MIN);
    }

    template<class T = int>
    constexpr fts_t min_to_fsec(T min) noexcept {
        return static_cast<fts_t>(min) * static_cast<fts_t>(SEC_PER_MIN);
    }

    template<class T = ts_t>
    constexpr double sec_to_fmin(T ts) noexcept {
        return static_cast<double>(ts) / static_cast<double>(SEC_PER_MIN);
    }
    
//----------------------------------------------------------------------------//
// Hours -> Milliseconds
//----------------------------------------------------------------------------//
 
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr ts_ms_t hour_to_ms_impl(T t, std::true_type tag) noexcept {
        return static_cast<ts_ms_t>(std::round(t * static_cast<T>(MS_PER_HOUR)));
    }

    template<class T>
    constexpr ts_ms_t hour_to_ms_impl(T t, std::false_type tag) noexcept {
        return static_cast<ts_ms_t>(t) * static_cast<ts_ms_t>(MS_PER_HOUR);
    }
#   endif // TIME_SHIELD_CPP17

    template<class T1 = ts_ms_t, class T2>
    constexpr T1 hour_to_ms(T2 ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr (std::is_floating_point_v<T2>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(MS_PER_HOUR)));
        } else {
            return static_cast<T1>(ts) * static_cast<T1>(MS_PER_HOUR);
        }
#       else
        return hour_to_ms_impl(ts, typename std::conditional<
            (std::is_same<T2, double>::value || std::is_same<T2, float>::value),
            std::true_type,
            std::false_type
        >::type{});
#       endif
    }

    template<class T1 = int, class T2 = ts_ms_t>
    constexpr T1 ms_to_hour(T2 ts) noexcept {
        return static_cast<T1>(ts) / static_cast<T1>(MS_PER_HOUR);
    }
 
//----------------------------------------------------------------------------//
// Hours -> Seconds
//----------------------------------------------------------------------------//
 
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr ts_t hour_to_sec_impl(T t, std::true_type tag) noexcept {
        return static_cast<ts_t>(std::round(t * static_cast<T>(SEC_PER_HOUR)));
    }

    template<class T>
    constexpr ts_t hour_to_sec_impl(T t, std::false_type tag) noexcept {
        return static_cast<ts_t>(t) * static_cast<ts_t>(SEC_PER_HOUR);
    }
#   endif // TIME_SHIELD_CPP17

    template<class T1 = ts_t, class T2>
    constexpr T1 hour_to_sec(T2 ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr (std::is_floating_point_v<T2>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(SEC_PER_HOUR)));
        } else {
            return static_cast<T1>(ts) * static_cast<T1>(SEC_PER_HOUR);
        }
#       else
        return hour_to_sec_impl(ts, typename std::conditional<
            (std::is_same<T2, double>::value || std::is_same<T2, float>::value),
            std::true_type,
            std::false_type
        >::type{});
#       endif
    }

    template<class T1 = int, class T2 = ts_t>
    constexpr T1 sec_to_hour(T2 ts) noexcept {
        return static_cast<T1>(ts) / static_cast<T1>(SEC_PER_HOUR);
    }

    template<class T = int>
    constexpr fts_t hour_to_fsec(T hr) noexcept {
        return static_cast<fts_t>(hr) * static_cast<fts_t>(SEC_PER_HOUR);
    }

    template<class T = ts_t>
    constexpr double sec_to_fhour(T ts) noexcept {
        return static_cast<double>(ts) / static_cast<double>(SEC_PER_HOUR);
    }
 
//------------------------------------------------------------------------------

    template<class T = year_t>
    constexpr T get_unix_year(ts_t ts) noexcept {
        // 9223372029693630000 - значение на момент 292277024400 от 2000 года
        // Такое значение приводит к неправильному вычислению умножения n_400_years * SEC_PER_400_YEARS
        // Поэтому пришлось снизить до 9223371890843040000
        constexpr int64_t BIAS_292277022000 = 9223371890843040000LL;
        constexpr int64_t BIAS_2000 = 946684800LL;
 
        int64_t y = MAX_YEAR;
        int64_t secs = -((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 * 400;
 
        const int64_t n_100_years = secs / SEC_PER_100_YEARS;
        secs -= n_100_years * SEC_PER_100_YEARS;
        y -= n_100_years * 100;
 
        const int64_t n_4_years = secs / SEC_PER_4_YEARS;
        secs -= n_4_years * SEC_PER_4_YEARS;
        y -= n_4_years * 4;
 
        const int64_t n_1_years = secs / SEC_PER_YEAR;
        secs -= n_1_years * SEC_PER_YEAR;
        y -= n_1_years;
 
        y = secs == 0 ? y : y - 1;
        return y - UNIX_EPOCH;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline T hour24_to_12(T hour) noexcept {
        if (hour == 0 || hour > 12) return 12;
        return hour;
    }
 
//------------------------------------------------------------------------------

    template<class T1 = DateTimeStruct, class T2 = ts_t>
    T1 to_date_time(T2 ts) {
        // 9223372029693630000 - значение на момент 292277024400 от 2000 года
        // Такое значение приводит к неправильному вычислению умножения n_400_years * SEC_PER_400_YEARS
        // Поэтому пришлось снизить до 9223371890843040000
        constexpr int64_t BIAS_292277022000 = 9223371890843040000LL;
        constexpr int64_t BIAS_2000 = 946684800LL;
 
        int64_t y = MAX_YEAR;
        uint64_t secs = -((ts - BIAS_2000) - BIAS_292277022000);
 
        const uint64_t n_400_years = secs / SEC_PER_400_YEARS;
        secs -= n_400_years * SEC_PER_400_YEARS;
        y -= n_400_years * 400;
 
        const uint64_t n_100_years = secs / SEC_PER_100_YEARS;
        secs -= n_100_years * SEC_PER_100_YEARS;
        y -= n_100_years * 100;
 
        const uint64_t n_4_years = secs / SEC_PER_4_YEARS;
        secs -= n_4_years * SEC_PER_4_YEARS;
        y -= n_4_years * 4;
 
        const uint64_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,  // 31 январь
            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,        // 28 февраль
            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,  // 31 март
            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,    // 30 апрель
            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,    // 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,             // 28 февраль
            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,    // 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,       // 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,
            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>(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;
    }
 
//------------------------------------------------------------------------------

    template<class T>
    inline T to_date_time_ms(ts_ms_t ts) {
        T date_time = to_date_time<T, ts_ms_t>(ms_to_sec<ts_ms_t, ts_ms_t>(ts));
        date_time.ms = ms_of_ts(ts); // Extract and set the ms component
        return date_time;
    }
 
//------------------------------------------------------------------------------

    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;
        uint64_t years = (static_cast<int64_t>(MAX_YEAR) - year);
 
        const int64_t n_400_years = years / 400;
        secs += n_400_years * SEC_PER_400_YEARS;
        years -= n_400_years * 400;
 
        const int64_t n_100_years = years / 100;
        secs += n_100_years * SEC_PER_100_YEARS;
        years -= n_100_years * 100;
 
        const int64_t n_4_years = years / 4;
        secs += n_4_years * SEC_PER_4_YEARS;
        years -= n_4_years * 4;
 
        secs += years * SEC_PER_YEAR;
 
        // 9223372029693630000 - значение на момент 292277024400 от 2000 года
        // Такое значение приводит к неправильному вычислению умножения n_400_years * SEC_PER_400_YEARS
        // Поэтому пришлось снизить до 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 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(
            timeinfo->tm_year + 1900,
            timeinfo->tm_mon + 1,
            timeinfo->tm_mday,
            timeinfo->tm_hour,
            timeinfo->tm_min,
            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) {
        return sec_to_ms(to_timestamp<T1, T2>(year, month, day, hour, min, sec)) + ms;
    }
 
//------------------------------------------------------------------------------

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t dt_to_timestamp_ms(
            const T& date_time) {
        return sec_to_ms(dt_to_timestamp(date_time)) + date_time.ms;
    }
 
//------------------------------------------------------------------------------

    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) {
        return static_cast<fts_t>(to_timestamp(year, month, day, hour, min, sec)) +
            static_cast<fts_t>(ms)/static_cast<fts_t>(MS_PER_SEC);
    }
 
//------------------------------------------------------------------------------

    template<class T>
    TIME_SHIELD_CONSTEXPR inline fts_t dt_to_ftimestamp(
            const T& date_time) {
        return static_cast<fts_t>(to_timestamp(date_time)) +
            static_cast<fts_t>(date_time.ms)/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));
    }
 
//------------------------------------------------------------------------------

    template<class Year, class Month, class Day>
    TIME_SHIELD_CONSTEXPR inline uday_t date_to_unix_day(
            Year year,
            Month month,
            Day day) noexcept {
        const int64_t y = static_cast<int64_t>(year) - (static_cast<int64_t>(month) <= 2 ? 1 : 0);
        const int64_t m = static_cast<int64_t>(month) <= 2
                ? static_cast<int64_t>(month) + 9
                : static_cast<int64_t>(month) - 3;
        const int64_t era = (y >= 0 ? y : y - 399) / 400;
        const int64_t yoe = y - era * 400;
        const int64_t doy = (153 * m + 2) / 5 + static_cast<int64_t>(day) - 1;
        const int64_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
        return static_cast<uday_t>(era * 146097 + doe - 719468);
    }

    template<class T = uday_t>
    constexpr T get_unix_day(ts_t ts = time_shield::ts()) noexcept {
        return ts / SEC_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T get_days_difference(ts_t start, ts_t stop) noexcept {
        return (stop - start) / SEC_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    template<class T = uday_t>
    constexpr T get_unix_day_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return get_unix_day(ms_to_sec(t_ms));
    }
 
//------------------------------------------------------------------------------

    template<class T = ts_t>
    constexpr T unix_day_to_timestamp(uday_t unix_day) noexcept {
        return unix_day * SEC_PER_DAY;
    }
 
//------------------------------------------------------------------------------
    
    template<class T = ts_t>
    constexpr T unix_day_to_timestamp_ms(uday_t unix_day) noexcept {
        return unix_day * MS_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    template<class T = ts_t>
    constexpr T end_of_day_from_unix_day(uday_t unix_day) noexcept {
        return unix_day * SEC_PER_DAY + SEC_PER_DAY - 1;
    }

    template<class T = ts_ms_t>
    constexpr T end_of_day_from_unix_day_ms(uday_t unix_day) noexcept {
        return unix_day * MS_PER_DAY + MS_PER_DAY - 1;
    }

    template<class T = ts_ms_t>
    constexpr T start_of_next_day_from_unix_day(uday_t unix_day) noexcept {
        return unix_day * SEC_PER_DAY + SEC_PER_DAY;
    }

    template<class T = ts_ms_t>
    constexpr T start_of_next_day_from_unix_day_ms(uday_t unix_day) noexcept {
        return unix_day * MS_PER_DAY + MS_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    template<class T = int64_t>
    constexpr T get_unix_min(ts_t ts = time_shield::ts()) {
        return ts / SEC_PER_MIN;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T sec_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ts % SEC_PER_DAY;
    }

    template<class T = int>
    constexpr T sec_of_day_ms(ts_ms_t ts_ms) noexcept {
        return sec_of_day(ms_to_sec(ts_ms));
    }

    template<class T1 = int, class T2 = int>
    constexpr T1 sec_of_day(
            T2 hour,
            T2 min,
            T2 sec) noexcept {
        return hour * SEC_PER_HOUR + min * SEC_PER_MIN + sec;
    }

    template<class T = int>
    constexpr T sec_of_min(ts_t ts = time_shield::ts()) {
        return (ts % SEC_PER_MIN);
    }

    template<class T = int>
    constexpr T sec_of_hour(ts_t ts = time_shield::ts()) {
        return (ts % SEC_PER_HOUR);
    }
 
//------------------------------------------------------------------------------

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T get_year(ts_t ts = time_shield::ts()) {
        return get_unix_year(ts) + UNIX_EPOCH;
    }
 
//------------------------------------------------------------------------------

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T get_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return get_year(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year(ts_t ts) noexcept {
        constexpr ts_t BIAS_2100 = 4102444800;
        if (ts < BIAS_2100) {
            constexpr ts_t SEC_PER_YEAR_X2 = SEC_PER_YEAR * 2;
            ts_t year_start_ts = 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 = 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 - secs % SEC_PER_YEAR;
                return start_ts;
            }
        }
 
        ts_t offset_4y = 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 - 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()) noexcept {
        return sec_to_ms(start_of_year(ms_to_sec(ts_ms)));
    }
 
//------------------------------------------------------------------------------

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year_date(T year) {
        if (year < 2100) {
            const ts_t year_diff = year >= UNIX_EPOCH ? year - UNIX_EPOCH : UNIX_EPOCH - year;
            const ts_t year_start_ts = (year_diff / 4) * SEC_PER_4_YEARS;
            const ts_t year_remainder = year_diff % 4;
            constexpr ts_t SEC_PER_YEAR_X2 = 2 * SEC_PER_YEAR;
            constexpr ts_t SEC_PER_YEAR_V2 = SEC_PER_YEAR_X2 + SEC_PER_LEAP_YEAR;
            switch (year_remainder) {
                case 0: return year_start_ts;
                case 1: return year_start_ts + SEC_PER_YEAR;
                case 2: return year_start_ts + SEC_PER_YEAR_X2;
                default: break;
            };
            return year_start_ts + SEC_PER_YEAR_V2;
        }
        return to_timestamp(year, 1, 1);
    }
 
//------------------------------------------------------------------------------

    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 end_of_year(ts_t ts = time_shield::ts()) {
        constexpr ts_t BIAS_2100 = 4102444800;
        if (ts < BIAS_2100) {
            constexpr ts_t SEC_PER_YEAR_X2 = SEC_PER_YEAR * 2;
            constexpr ts_t SEC_PER_YEAR_X3 = SEC_PER_YEAR * 3;
            constexpr ts_t SEC_PER_YEAR_X3_V2 = SEC_PER_YEAR_X2 + SEC_PER_LEAP_YEAR;
            ts_t year_end_ts = ts % SEC_PER_4_YEARS;
            if (year_end_ts < SEC_PER_YEAR) {
                return ts + SEC_PER_YEAR - year_end_ts - 1;
            } else
            if (year_end_ts < SEC_PER_YEAR_X2) {
                return ts + SEC_PER_YEAR_X2 - year_end_ts - 1;
            } else
            if (year_end_ts < SEC_PER_YEAR_X3_V2) {
                return ts + SEC_PER_YEAR_X3_V2 - year_end_ts - 1;
            }
            return ts + (SEC_PER_YEAR_X3 + SEC_PER_LEAP_YEAR) - year_end_ts - 1;
        }
 
        constexpr ts_t BIAS_2000 = 946684800;
        ts_t secs = ts - BIAS_2000;
 
        ts_t offset_y400 = secs % SEC_PER_400_YEARS;
        ts_t end_ts = secs - offset_y400 + BIAS_2000;
        secs = offset_y400;
 
        if (secs >= SEC_PER_FIRST_100_YEARS) {
            secs -= SEC_PER_FIRST_100_YEARS;
            end_ts += SEC_PER_FIRST_100_YEARS;
            while (secs >= SEC_PER_100_YEARS) {
                secs -= SEC_PER_100_YEARS;
                end_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;
                end_ts += SEC_PER_4_YEARS_V2;
            } else {
                end_ts += secs - secs % SEC_PER_YEAR;
                return end_ts + SEC_PER_YEAR - 1;
            }
        }
 
        ts_t offset_4y = secs % SEC_PER_4_YEARS;
        end_ts += secs - offset_4y;
        secs = offset_4y;
 
        if (secs >= SEC_PER_LEAP_YEAR) {
            secs -= SEC_PER_LEAP_YEAR;
            end_ts += SEC_PER_LEAP_YEAR;
            end_ts += secs - secs % SEC_PER_YEAR;
            end_ts += SEC_PER_YEAR;
        } else {
            end_ts += SEC_PER_LEAP_YEAR;
        }
        return end_ts - 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_ms)));
    }
 
//------------------------------------------------------------------------------

    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,  // 31 январь
            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,        // 28 февраль
            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,  // 31 март
            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,    // 30 апрель
            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(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;
        // таблица для обычного года, не високосного
        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,    // 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,             // 28 февраль
            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,    // 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,       // 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,
            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(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>
    constexpr T1 num_days_in_month(T2 year, T3 month) noexcept {
        if (month > MONTHS_PER_YEAR || month < 0) return 0;
        constexpr T1 num_days[13] = {0,31,30,31,30,31,30,31,31,30,31,30,31};
        if (month == FEB) {
            if (is_leap_year_date(year)) return 29;
            return 28;
        }
        return 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(ts);
        if (month == FEB) {
            return is_leap_year(ts) ? 29 : 28;
        }
        return num_days[month];
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline int first_workday_day(year_t year, int month) noexcept {
        const int days = num_days_in_month(year, month);
        if (days <= 0) {
            return 0;
        }
        for (int day = 1; day <= days; ++day) {
            if (is_workday(year, month, day)) {
                return day;
            }
        }
        return 0;
    }

    TIME_SHIELD_CONSTEXPR inline int last_workday_day(year_t year, int month) noexcept {
        const int days = num_days_in_month(year, month);
        if (days <= 0) {
            return 0;
        }
        for (int day = days; day >= 1; --day) {
            if (is_workday(year, month, day)) {
                return day;
            }
        }
        return 0;
    }

    TIME_SHIELD_CONSTEXPR inline int count_workdays_in_month(year_t year, int month) noexcept {
        const int days = num_days_in_month(year, month);
        if (days <= 0) {
            return 0;
        }
        int total = 0;
        for (int day = 1; day <= days; ++day) {
            if (is_workday(year, month, day)) {
                ++total;
            }
        }
        return total;
    }

    TIME_SHIELD_CONSTEXPR inline int workday_index_in_month(year_t year, int month, int day) noexcept {
        if (!is_workday(year, month, day)) {
            return 0;
        }
        const int days = num_days_in_month(year, month);
        if (days <= 0) {
            return 0;
        }
        int index = 0;
        for (int current = 1; current <= days; ++current) {
            if (is_workday(year, month, current)) {
                ++index;
                if (current == day) {
                    return index;
                }
            }
        }
        return 0;
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_first_workday_of_month(year_t year, int month, int day) noexcept {
        return is_workday(year, month, day) && first_workday_day(year, month) == day;
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_first_workdays_of_month(year_t year, int month, int day, int count) noexcept {
        if (count <= 0) {
            return false;
        }
        const int total = count_workdays_in_month(year, month);
        if (count > total) {
            return false;
        }
        const int index = workday_index_in_month(year, month, day);
        return index > 0 && index <= count;
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_last_workday_of_month(year_t year, int month, int day) noexcept {
        return is_workday(year, month, day) && last_workday_day(year, month) == day;
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_last_workdays_of_month(year_t year, int month, int day, int count) noexcept {
        if (count <= 0) {
            return false;
        }
        const int total = count_workdays_in_month(year, month);
        if (count > total) {
            return false;
        }
        const int index = workday_index_in_month(year, month, day);
        return index > 0 && index >= (total - count + 1);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_first_workday_of_month(ts_t ts) noexcept {
        const year_t year = get_year(ts);
        const int month = month_of_year(ts);
        const int day = day_of_month(ts);
        return is_first_workday_of_month(year, month, day);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_first_workdays_of_month(ts_t ts, int count) noexcept {
        const year_t year = get_year(ts);
        const int month = month_of_year(ts);
        const int day = day_of_month(ts);
        return is_within_first_workdays_of_month(year, month, day, count);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_last_workday_of_month(ts_t ts) noexcept {
        const year_t year = get_year(ts);
        const int month = month_of_year(ts);
        const int day = day_of_month(ts);
        return is_last_workday_of_month(year, month, day);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_last_workdays_of_month(ts_t ts, int count) noexcept {
        const year_t year = get_year(ts);
        const int month = month_of_year(ts);
        const int day = day_of_month(ts);
        return is_within_last_workdays_of_month(year, month, day, count);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_first_workday_of_month_ms(ts_ms_t ts_ms) noexcept {
        return is_first_workday_of_month(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_first_workdays_of_month_ms(ts_ms_t ts_ms, int count) noexcept {
        return is_within_first_workdays_of_month(ms_to_sec(ts_ms), count);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_last_workday_of_month_ms(ts_ms_t ts_ms) noexcept {
        return is_last_workday_of_month(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_within_last_workdays_of_month_ms(ts_ms_t ts_ms, int count) noexcept {
        return is_within_last_workdays_of_month(ms_to_sec(ts_ms), count);
    }
 
//------------------------------------------------------------------------------

    template<class T1 = int, class T2 = year_t>
    constexpr T1 num_days_in_year(T2 year) noexcept {
        if (is_leap_year_date(year)) return DAYS_PER_LEAP_YEAR;
        return DAYS_PER_YEAR;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T num_days_in_year_ts(ts_t ts = time_shield::ts()) {
        if (is_leap_year_ts(ts)) return DAYS_PER_LEAP_YEAR;
        return DAYS_PER_YEAR;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_DAY);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_t start_of_prev_day(ts_t ts = time_shield::ts(), T days = 1) noexcept {
        return ts - (ts % SEC_PER_DAY) - SEC_PER_DAY * days;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_day_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_day(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    constexpr ts_ms_t start_of_day_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_DAY);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    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>
    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>
    constexpr ts_t next_day(ts_t ts, T days = 1) noexcept {
        return ts + days * SEC_PER_DAY;
    }

    template<class T = int>
    constexpr ts_ms_t next_day_ms(ts_ms_t ts_ms, T days = 1) noexcept {
        return ts_ms + days * MS_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_DAY) + SEC_PER_DAY - 1;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_day_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_day(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    constexpr ts_ms_t end_of_day_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_DAY) + MS_PER_DAY - 1;
    }
 
//------------------------------------------------------------------------------

    template<class T1 = Weekday, class T2 = year_t, class T3 = int, class T4 = int>
    constexpr T1 day_of_week_date(T2 year, T3 month, T4 day) {
        year_t a, y, m, R;
        a = (14 - month) / MONTHS_PER_YEAR;
        y = year - a;
        m = month + MONTHS_PER_YEAR * a - 2;
        R = 7000 + ( day + y + (y / 4) - (y / 100) + (y / 400) + (31 * m) / MONTHS_PER_YEAR);
        return static_cast<T1>(R % DAYS_PER_WEEK);
    }
 
//------------------------------------------------------------------------------

    template<class T1 = Weekday, class T2>
    constexpr T1 get_weekday_from_date(const T2& date) {
        return day_of_week_date(date.year, date.mon, date.day);
    }
 
//------------------------------------------------------------------------------

    template<class T = Weekday>
    constexpr T get_weekday_from_ts(ts_t ts) noexcept {
        return static_cast<T>((ts / SEC_PER_DAY + THU) % DAYS_PER_WEEK);
    }
 
//------------------------------------------------------------------------------

    template<class T = Weekday>
    constexpr T get_weekday_from_ts_ms(ts_ms_t ts_ms) {
        return get_weekday_from_ts(ms_to_sec(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()) {
        return end_of_month(ts) - get_weekday_from_ts(ts) * 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);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_HOUR);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_hour_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_hour(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    constexpr ts_ms_t start_of_hour_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_HOUR);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_HOUR) + SEC_PER_HOUR - 1;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_hour_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_hour(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------

    constexpr ts_ms_t end_of_hour_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_HOUR) + MS_PER_HOUR - 1;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T hour_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ((ts / SEC_PER_HOUR) % HOURS_PER_DAY);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_week(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) - get_weekday_from_ts(ts) * SEC_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_week(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) + (DAYS_PER_WEEK - get_weekday_from_ts(ts)) * SEC_PER_DAY - 1;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_saturday(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) + (SAT - get_weekday_from_ts(ts)) * SEC_PER_DAY;
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t start_of_min(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_MIN);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t end_of_min(ts_t ts = time_shield::ts()) noexcept {
        return ts - (ts % SEC_PER_MIN) + SEC_PER_MIN - 1;
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T min_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ((ts / SEC_PER_MIN) % MIN_PER_DAY);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T min_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return ((ts / SEC_PER_MIN) % MIN_PER_HOUR);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_t start_of_period(T p, ts_t ts = time_shield::ts()) {
        return ts - (ts % p);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_t end_of_period(T p, ts_t ts = time_shield::ts()) {
        return ts - (ts % p) + p - 1;
    }
 
//------------------------------------------------------------------------------

    template<class T = TimeZoneStruct>
    inline T to_time_zone(tz_t offset) {
        T tz;
        int abs_val = std::abs(offset);
        tz.hour = abs_val / SEC_PER_HOUR;
        tz.min = (abs_val % SEC_PER_HOUR) / SEC_PER_MIN;
        tz.is_positive = (offset >= 0);
        return tz;
    }

 
}; // namespace time_shield
 
#include "time_conversion_aliases.hpp"
 
#endif // _TIME_SHIELD_TIME_CONVERSIONS_HPP_INCLUDED