time_conversions.hpp

Go to the documentation of this file.

#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 <cmath>
#include <ctime>
 
namespace time_shield {
 
    template<class T = int>
    constexpr const T ns_of_sec(const 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 const T us_of_sec(const 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 const T ms_of_sec(const 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 const T ms_of_ts(const ts_ms_t& ts) noexcept {
        return ts % MS_PER_SEC;
    }
 
#   ifndef TIME_SHIELD_CPP17
    template<class T>
    constexpr const ts_ms_t sec_to_ms_impl(const T& t, std::true_type) noexcept {
        return static_cast<ts_ms_t>(std::round(t * static_cast<T>(MS_PER_SEC)));
    }
 
    template<class T>
    constexpr const ts_ms_t sec_to_ms_impl(const T& t, std::false_type) noexcept {
        return static_cast<ts_ms_t>(t) * static_cast<ts_ms_t>(MS_PER_SEC);
    }
#   endif
 
    template<class T1 = ts_ms_t, class T2>
    constexpr const T1 sec_to_ms(const T2& ts) noexcept {
#       ifdef TIME_SHIELD_CPP17
        if constexpr(std::is_same_v<T2, double>) {
            return static_cast<T1>(std::round(ts * static_cast<T2>(MS_PER_SEC)));
        } else
        if constexpr(std::is_same_v<T2, float>) {
            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, std::is_same<T2, double>());
#       endif
    }
 
    constexpr const ts_ms_t fsec_to_ms(const 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 const T1 ms_to_sec(const T2& ts_ms) noexcept {
        return static_cast<T1>(ts_ms) / static_cast<T1>(MS_PER_SEC);
    }
 
    template<class T = ts_ms_t>
    constexpr const fts_t ms_to_fsec(const T& ts_ms) noexcept {
        return static_cast<fts_t>(ts_ms) / static_cast<fts_t>(MS_PER_SEC);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    constexpr const T get_unix_year(const 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 = year_t>
    constexpr const T unix_year(const ts_t& ts) noexcept {
        return get_unix_year(ts);
    }
 
    template<class T = year_t>
    constexpr const T to_unix_year(const ts_t& ts) noexcept {
        return get_unix_year(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline const T hour24_to_12(const T& hour) noexcept {
        if (hour == 0 || hour > 12) return 12;
        return hour;
    }
 
    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline const T h24_to_h12(const T& hour) noexcept {
        return hour24_to_12(hour);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1, class T2 = ts_t>
    T1 to_date_time(const 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 = 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 = secs % SEC_PER_DAY;
        date_time.hour = day_secs / SEC_PER_HOUR;
        ts_t min_secs = day_secs - date_time.hour * SEC_PER_HOUR;
        date_time.min = min_secs / SEC_PER_MIN;
        date_time.sec = min_secs - date_time.min * SEC_PER_MIN;
#       ifdef TIME_SHIELD_CPP17
        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 T1, class T2 = ts_t>
    T1 to_dt(const T2& ts) {
        return to_date_time(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T>
    inline T to_date_time_ms(const 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 T>
    inline T to_dt_ms(const ts_ms_t& ts) {
        return to_date_time_ms<T>(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_timestamp(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const 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 T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_ts(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0) {
        return to_timestamp<T1, T2>(year, month, day, hour, min, sec);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t get_ts(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0) {
        return to_timestamp<T1, T2>(year, month, day, hour, min, sec);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t ts(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0) {
        return to_timestamp<T1, T2>(year, month, day, hour, min, sec);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t timestamp(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0) {
        return to_timestamp<T1, T2>(year, month, day, hour, min, sec);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_t get_timestamp(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0) {
        return to_timestamp<T1, T2>(year, month, day, hour, min, sec);
    }
 
//------------------------------------------------------------------------------
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const 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);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_timestamp(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_ts(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t ts(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t timestamp(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const 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);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t to_timestamp(
            const std::tm *timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t to_ts(
            const std::tm *timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t ts(
            const std::tm *timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t timestamp(
            const std::tm *timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t ts_from_tm(
            const std::tm *timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t to_timestamp_ms(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T2& ms    = 0) {
        return sec_to_ms(to_timestamp<T1, T2>(year, month, day, hour, min, sec)) + ms;
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t to_ts_ms(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T2& ms    = 0) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t ts_ms(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T2& ms    = 0) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }
 
    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t timestamp_ms(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T2& ms    = 0) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t dt_to_timestamp_ms(
            const T& date_time) {
        return sec_to_ms(dt_to_timestamp(date_time)) + date_time.ms;
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_timestamp_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t to_ts_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t ts_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const ts_t timestamp_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_t tm_to_timestamp_ms(
            const std::tm *timeinfo) {
        return sec_to_ms(tm_to_timestamp(timeinfo));
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t to_timestamp_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t to_ts_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t ts_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t timestamp_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const fts_t to_ftimestamp(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const 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 T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const fts_t to_fts(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T3& ms    = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }
 
    template<class T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const fts_t fts(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T3& ms    = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }
 
    template<class T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const fts_t ftimestamp(
            const T1& year,
            const T2& month,
            const T2& day,
            const T2& hour  = 0,
            const T2& min   = 0,
            const T2& sec   = 0,
            const T3& ms    = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const 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);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const fts_t to_ftimestamp(
            const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const fts_t to_fts(
            const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const fts_t fts(
            const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }
 
    template<class T>
    TIME_SHIELD_CONSTEXPR inline const fts_t ftimestamp(
            const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const fts_t tm_to_ftimestamp(
            const std::tm* timeinfo) {
        return static_cast<fts_t>(tm_to_timestamp(timeinfo));
    }
 
    TIME_SHIELD_CONSTEXPR inline const fts_t to_ftimestamp(
            const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const fts_t to_fts(
            const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const fts_t fts(
            const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
 
    TIME_SHIELD_CONSTEXPR inline const fts_t ftimestamp(
            const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = uday_t>
    constexpr const T get_unix_day(const ts_t& ts = ts()) noexcept {
        return ts / SEC_PER_DAY;
    }
 
    template<class T = uday_t>
    constexpr const T unix_day(const ts_t& ts = ts()) noexcept {
        return get_unix_day(ts);
    }
 
    template<class T = uday_t>
    constexpr const T uday(const ts_t& ts = ts()) noexcept {
        return get_unix_day(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T get_days_difference(const ts_t& start, const ts_t& stop) noexcept {
        return (stop - start) / SEC_PER_DAY;
    }
 
    template<class T = int>
    constexpr const T get_days(const ts_t& start, const ts_t& stop) noexcept {
        return get_days_difference(start, stop);
    }
 
    template<class T = int>
    constexpr const T days(const ts_t& start, const ts_t& stop) noexcept {
        return get_days_difference(start, stop);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = uday_t>
    constexpr const T get_unix_day_ms(const ts_ms_t& t_ms = ts_ms()) noexcept {
        return get_unix_day(ms_to_sec(t_ms));
    }
 
    template<class T = uday_t>
    constexpr const T unix_day_ms(const ts_ms_t& t_ms = ts_ms()) noexcept {
        return get_unix_day_ms(t_ms);
    }
 
    template<class T = uday_t>
    constexpr const T uday_ms(const ts_ms_t& t_ms = ts_ms()) noexcept {
        return get_unix_day_ms(t_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = ts_t>
    constexpr const T unix_day_to_timestamp(const uday_t& unix_day) noexcept {
        return unix_day * SEC_PER_DAY;
    }
 
    template<class T = ts_t>
    constexpr const T unix_day_to_ts(const uday_t& unix_day) noexcept {
        return unix_day_to_timestamp(unix_day);
    }
 
    template<class T = ts_t>
    constexpr const T uday_to_ts(const uday_t& unix_day) noexcept {
        return unix_day_to_timestamp(unix_day);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int64_t>
    constexpr const T get_unix_min(const ts_t& ts = ts()) {
        return ts / SEC_PER_MIN;
    }
 
    template<class T = int64_t>
    constexpr const T unix_min(const ts_t& ts = ts()) {
        return get_unix_min(ts);
    }
 
    template<class T = int64_t>
    constexpr const T to_unix_min(const ts_t& ts = ts()) {
        return get_unix_min(ts);
    }
 
    template<class T = int64_t>
    constexpr const T umin(const ts_t& ts = ts()) {
        return get_unix_min(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T sec_of_day(const ts_t& ts = ts()) {
        return ts % SEC_PER_DAY;
    }
 
    template<class T = int>
    constexpr const T sec_of_day_ms(const ts_ms_t& ts_ms) noexcept {
        return sec_of_day(ms_to_sec(ts_ms));
    }
 
    template<class T1 = int, class T2 = int>
    constexpr const T1 sec_of_day(
            const T2& hour,
            const T2& min,
            const T2& sec) noexcept {
        return hour * SEC_PER_HOUR + min * SEC_PER_MIN + sec;
    }
 
    template<class T = int>
    constexpr const T sec_of_min(const ts_t& ts = ts()) {
        return (ts % SEC_PER_MIN);
    }
 
    template<class T = int>
    constexpr const T sec_of_hour(const ts_t& ts = ts()) {
        return (ts % SEC_PER_HOUR);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T get_year(const ts_t& ts = ts()) {
        return get_unix_year(ts) + UNIX_EPOCH;
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T year(const ts_t& ts = ts()) {
        return get_year(ts);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T to_year(const ts_t& ts = ts()) {
        return get_year(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T get_year_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return get_year(ms_to_sec(ts_ms));
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T year_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return get_year_ms(ts_ms);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const T to_year_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return get_year_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_t start_of_year(const 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 const ts_t year_start(const ts_t& ts = ts()) {
        return start_of_year(ts);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t year_begin(const ts_t& ts = ts()) {
        return start_of_year(ts);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t start_of_year_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return sec_to_ms(start_of_year(ms_to_sec(ts_ms)));
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t year_start_ms(const ts_t& ts_ms = ts_ms()) {
        return start_of_year_ms(ts_ms);
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t year_begin_ms(const ts_t& ts_ms = ts_ms()) {
        return start_of_year_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_t start_of_year_date(const 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: return year_start_ts + SEC_PER_YEAR_V2;
            };
            return year_start_ts + SEC_PER_YEAR_V2;
        }
        return to_timestamp(year, 1, 1);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_t year_start_date(const T& year) {
        return start_of_year_date(year);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_t year_begin_date(const T& year) {
        return start_of_year_date(year);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t start_of_year_date_ms(const T& year) {
        return sec_to_ms(start_of_year_date(year));
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t year_start_date_ms(const T& year) {
        return start_of_year_date_ms(year);
    }
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t year_begin_date_ms(const T& year) {
        return start_of_year_date_ms(year);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline ts_t end_of_year(const ts_t& ts = 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;
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t year_end(const ts_t& ts = ts()) {
        return end_of_year(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t end_of_year_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return sec_to_ms(end_of_year(ms_to_sec(ts_ms)));
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_ms_t year_end_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return end_of_year_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    inline const T day_of_year(const ts_t& ts = ts()) {
        return ((ts - start_of_year(ts)) / SEC_PER_DAY) + 1;
    }
 
//------------------------------------------------------------------------------
 
    template<class T = Month>
    TIME_SHIELD_CONSTEXPR inline const T month_of_year(const 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 const T day_of_month(const ts_t& 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 const T1 num_days_in_month(const T2& year, const 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, class T2 = year_t, class T3 = int>
    constexpr const T1 days_in_month(const T2& year, const T3& month) noexcept {
        return num_days_in_month(year, month);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = int>
    TIME_SHIELD_CONSTEXPR const T1 num_days_in_month_ts(const ts_t& ts = 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];
    }
 
    template<class T1 = int>
    constexpr const T1 num_days_in_month(const ts_t& ts = ts()) noexcept {
        return num_days_in_month_ts(ts);
    }
 
    template<class T1 = int>
    constexpr const T1 days_in_month(const ts_t& ts = ts()) noexcept {
        return num_days_in_month_ts(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = int, class T2 = year_t>
    constexpr const T1 num_days_in_year(const T2& year) noexcept {
        if (is_leap_year_date(year)) return DAYS_PER_LEAP_YEAR;
        return DAYS_PER_YEAR;
    }
 
    template<class T1 = int, class T2 = year_t>
    constexpr const T1 days_in_year(const T2& year) noexcept {
        return num_days_in_year(year);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T num_days_in_year_ts(const ts_t& ts = ts()) {
        if (is_leap_year_ts(ts)) return DAYS_PER_LEAP_YEAR;
        return DAYS_PER_YEAR;
    }
 
    template<class T = int>
    constexpr const T days_in_year_ts(const ts_t& ts = ts()) {
        return num_days_in_year_ts(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_day(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_DAY);
    }
 
    constexpr const ts_t day_start(const ts_t& ts = ts()) noexcept {
        return start_of_day(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const ts_t start_of_prev_day(const ts_t& ts = ts(), const T& days = 1) {
        return ts - (ts % SEC_PER_DAY) - SEC_PER_DAY * days;
    }
 
    template<class T = int>
    constexpr const ts_t previous_day_start(const ts_t& ts = ts(), const T& days = 1) {
        return start_of_prev_day(ts, days);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_day_sec(const ts_ms_t& ts_ms = ts_ms()) {
        return start_of_day(ms_to_sec(ts_ms));
    }
 
    constexpr const ts_t day_start_sec(const ts_ms_t& ts_ms = ts_ms()) {
        return start_of_day_sec(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_ms_t start_of_day_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return ts_ms - (ts_ms % MS_PER_DAY);
    }
 
    constexpr const ts_ms_t day_start_ms(const ts_ms_t& ts_ms = ts_ms()) {
        return start_of_day_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const ts_t start_of_next_day(const ts_t& ts, const T& days = 1) {
        return start_of_day(ts) + days * SEC_PER_DAY;
    }
 
    template<class T = int>
    constexpr const ts_t next_day_start(const ts_t& ts, const T& days = 1) {
        return start_of_next_day(ts, days);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_day(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_DAY) + SEC_PER_DAY - 1;
    }
 
    constexpr const ts_t day_end(const ts_t& ts = ts()) noexcept {
        return end_of_day(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_day_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_day(ms_to_sec(ts_ms));
    }
 
    constexpr const ts_t day_end_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_day_sec(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_ms_t end_of_day_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_DAY) + MS_PER_DAY - 1;
    }
 
    constexpr const ts_ms_t day_end_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_day_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = Weekday, class T2 = year_t, class T3 = int>
    constexpr const T1 day_of_week_date(const T2& year, const T3& month, const T3& 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 = year_t, class T3 = int>
    constexpr const T1 get_weekday(const T2& year, const T3& month, const T3& day) {
        return day_of_week_date(year, month, day);
    }
 
    template<class T1 = Weekday, class T2 = year_t, class T3 = int>
    constexpr const T1 day_of_week(const T2& year, const T3& month, const T3& day) {
        return day_of_week_date(year, month, day);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = Weekday, class T2>
    constexpr const T1 get_weekday_from_date(const T2& date) {
        return day_of_week_date(date.year, date.mon, date.day);
    }
 
    template<class T1 = int, class T2>
    constexpr const T1 day_of_week_dt(const T2& date) {
        return get_weekday_from_date(date);
    }
 
    template<class T1 = int, class T2>
    constexpr const T1 day_of_week(const T2& date) {
        return get_weekday_from_date(date);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = Weekday>
    constexpr const T get_weekday_from_ts(const ts_t& ts) noexcept {
        return static_cast<T>((ts / SEC_PER_DAY + THU) % DAYS_PER_WEEK);
    }
 
    template<class T = Weekday>
    constexpr const T day_of_week(const ts_t& ts) noexcept {
        return get_weekday_from_ts(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = Weekday>
    constexpr const T get_weekday_from_ts_ms(const ts_ms_t& ts_ms) {
        return get_weekday_from_ts(ms_to_sec(ts_ms));
    }
 
    template<class T = Weekday>
    constexpr const T day_of_week_ms(const ts_ms_t& ts_ms) {
        return get_weekday_from_ts_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_t start_of_month(const ts_t& ts = ts()) {
        return start_of_day(ts) - (day_of_month(ts) - 1) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t month_begin(const ts_t& ts = ts()) {
        return start_of_month(ts);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_t end_of_month(const ts_t& ts = ts()) {
        return end_of_day(ts) + (num_days_in_month(ts) - day_of_month(ts)) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t last_day_of_month(const ts_t& ts = ts()) {
        return end_of_month(ts);
    }
 
//------------------------------------------------------------------------------
 
    TIME_SHIELD_CONSTEXPR inline const ts_t last_sunday_of_month(const ts_t& ts = ts()) {
        return end_of_month(ts) - day_of_week(ts) * SEC_PER_DAY;
    }
 
    TIME_SHIELD_CONSTEXPR inline const ts_t final_sunday_of_month(const ts_t& ts = ts()) {
        return last_sunday_of_month(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T1 = int, class T2 = year_t, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const T1 last_sunday_month_day(const T2& year, const T3& month) {
        const T1 days = num_days_in_month(year, month);
        return days - day_of_week_date(year, month, days);
    }
 
    template<class T1 = int, class T2 = year_t, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline const T1 final_sunday_month_day(const T2& year, const T3& month) {
        return last_sunday_month_day(year, month);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_hour(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_HOUR);
    }
 
    constexpr const ts_t hour_begin(const ts_t& ts = ts()) noexcept {
        return start_of_hour(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_hour_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return start_of_hour(ms_to_sec(ts_ms));
    }
 
    constexpr const ts_t hour_begin_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return start_of_hour_sec(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_ms_t start_of_hour_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_HOUR);
    }
 
    constexpr const ts_ms_t hour_begin_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return start_of_hour_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_hour(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_HOUR) + SEC_PER_HOUR - 1;
    }
 
    constexpr const ts_t finish_of_hour(const ts_t& ts = ts()) noexcept {
        return end_of_hour(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_hour_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_hour(ms_to_sec(ts_ms));
    }
 
    constexpr const ts_t finish_of_hour_sec(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_hour_sec(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_ms_t end_of_hour_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return ts_ms - (ts_ms % MS_PER_HOUR) + MS_PER_HOUR - 1;
    }
 
    constexpr const ts_ms_t finish_of_hour_ms(const ts_ms_t& ts_ms = ts_ms()) noexcept {
        return end_of_hour_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T hour_of_day(const ts_t& ts = ts()) noexcept {
        return ((ts / SEC_PER_HOUR) % HOURS_PER_DAY);
    }
 
    template<class T = int>
    constexpr const T hour_in_day(const ts_t& ts = ts()) noexcept {
        return hour_of_day(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_week(const ts_t& ts = ts()) {
        return start_of_day(ts) - day_of_week(ts) * SEC_PER_DAY;
    }
 
    constexpr const ts_t week_begin(const ts_t& ts = ts()) {
        return start_of_week(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_week(const ts_t& ts = ts()) {
        return start_of_day(ts) + (DAYS_PER_WEEK - day_of_week(ts)) * SEC_PER_DAY - 1;
    }
 
    constexpr const ts_t finish_of_week(const ts_t& ts = ts()) {
        return end_of_week(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_saturday(const ts_t& ts = ts()) {
        return start_of_day(ts) + (SAT - day_of_week(ts)) * SEC_PER_DAY;
    }
 
    constexpr const ts_t saturday_begin(const ts_t& ts = ts()) {
        return start_of_saturday(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t start_of_min(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_MIN);
    }
 
    constexpr const ts_t min_begin(const ts_t& ts = ts()) noexcept {
        return start_of_min(ts);
    }
 
//------------------------------------------------------------------------------
 
    constexpr const ts_t end_of_min(const ts_t& ts = ts()) noexcept {
        return ts - (ts % SEC_PER_MIN) + SEC_PER_MIN - 1;
    }
 
    constexpr const ts_t finish_of_min(const ts_t& ts = ts()) noexcept {
        return end_of_min(ts);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T min_of_day(const ts_t& ts = ts()) noexcept {
        return ((ts / SEC_PER_MIN) % MIN_PER_DAY);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const T min_of_hour(const ts_t& ts = ts()) noexcept {
        return ((ts / SEC_PER_MIN) % MIN_PER_HOUR);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const ts_t start_of_period(const T& p, const ts_t& ts = ts()) {
        return ts - (ts % p);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = int>
    constexpr const ts_t end_of_period(const T& p, const ts_t& ts = ts()) {
        return ts - (ts % p) + p - 1;
    }
 
//------------------------------------------------------------------------------
 
    template<class T = TimeZoneStruct>
    inline const TimeZoneStruct to_time_zone(
            const tz_t& offset) {
        T tz;
        int abs_val = std::abs(offset);
        tz.hour = abs_val / SEC_PER_HOUR;
        tz.min = abs_val % SEC_PER_MIN;
        tz.is_positive = (offset >= 0);
        return tz;
    }
 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_TIME_CONVERSIONS_HPP_INCLUDED