date_time_conversions.hpp

Go to the documentation of this file.

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

 
#include "config.hpp"
#include "constants.hpp"
#include "date_conversions.hpp"
#include "date_struct.hpp"
#include "date_time_struct.hpp"
#include "enums.hpp"
#include "time_unit_conversions.hpp"
#include "time_utils.hpp"
#include "unix_time_conversions.hpp"
#include "validation.hpp"
 
#include <cmath>
#include <ctime>
#include <stdexcept>
#include <type_traits>
 
namespace time_shield {


    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;
        int64_t secs = -((static_cast<int64_t>(ts) - BIAS_2000) - BIAS_292277022000);
 
        const int64_t n_400_years = secs / SEC_PER_400_YEARS;
        secs -= n_400_years * SEC_PER_400_YEARS;
        y -= n_400_years * 400LL;
 
        const int64_t n_100_years = secs / SEC_PER_100_YEARS;
        secs -= n_100_years * SEC_PER_100_YEARS;
        y -= n_100_years * 100LL;
 
        const int64_t n_4_years = secs / SEC_PER_4_YEARS;
        secs -= n_4_years * SEC_PER_4_YEARS;
        y -= n_4_years * 4LL;
 
        const int64_t n_1_years = secs / SEC_PER_YEAR;
        secs -= n_1_years * SEC_PER_YEAR;
        y -= n_1_years;
 
        T1 date_time;
 
        if (secs == 0) {
            date_time.year = y;
            date_time.mon = 1;
            date_time.day = 1;
            return date_time;
        }
 
        date_time.year = y - 1;
        const bool is_leap_year = is_leap_year_date(date_time.year);
        secs = is_leap_year ? SEC_PER_LEAP_YEAR - secs : SEC_PER_YEAR - secs;
        const int days = static_cast<int>(secs / SEC_PER_DAY);
 
        constexpr int JAN_AND_FEB_DAY_LEAP_YEAR = 60 - 1;
        constexpr int TABLE_MONTH_OF_YEAR[] = {
            1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // 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) {
        const ts_t sec = ms_to_sec<ts_t, ts_ms_t>(ts);
        T date_time = to_date_time<T, ts_t>(sec);
        date_time.ms = ms_of_ts(ts); // Extract and set the ms component
        return date_time;
    }

    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp(
            T1 year,
            T2 month,
            T2 day,
            T2 hour  = 0,
            T2 min   = 0,
            T2 sec   = 0) {
 
        if (day >= UNIX_EPOCH && year <= 31) {
            return to_timestamp((T1)day, month, (T2)year, hour, min, sec);
        }
        if (!is_valid_date_time(year, month, day, hour, min, sec)) {
            throw std::invalid_argument("Invalid date-time combination");
        }
 
        int64_t secs = 0;
        int64_t years = (static_cast<int64_t>(MAX_YEAR) - year);
 
        const int64_t n_400_years = years / 400LL;
        secs += n_400_years * SEC_PER_400_YEARS;
        years -= n_400_years * 400LL;
 
        const int64_t n_100_years = years / 100LL;
        secs += n_100_years * SEC_PER_100_YEARS;
        years -= n_100_years * 100LL;
 
        const int64_t n_4_years = years / 4LL;
        secs += n_4_years * SEC_PER_4_YEARS;
        years -= n_4_years * 4LL;
 
        secs += years * SEC_PER_YEAR;
 
        // 9223372029693630000 - значение на момент 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(
            static_cast<year_t>(timeinfo->tm_year + 1900),
            static_cast<int>(timeinfo->tm_mon + 1),
            static_cast<int>(timeinfo->tm_mday),
            static_cast<int>(timeinfo->tm_hour),
            static_cast<int>(timeinfo->tm_min),
            static_cast<int>(timeinfo->tm_sec)
        );
    }

    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_timestamp_ms(
            T1 year,
            T2 month,
            T2 day,
            T2 hour = 0,
            T2 min  = 0,
            T2 sec  = 0,
            T2 ms   = 0) {
        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));
    }

    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_t>(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_t>(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 T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year_date(T year) {
        const ts_t year_ts = to_timestamp(year, 1, 1);
 
        return start_of_day(year_ts);
    }

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_year_date_ms(T year) {
        return sec_to_ms(start_of_year_date(year));
    }

    TIME_SHIELD_CONSTEXPR inline ts_t start_of_year(ts_t ts) noexcept {
        constexpr ts_t BIAS_2100 = 4102444800;
        if (ts < 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;
        }
        else {
            start_ts += secs - secs % SEC_PER_YEAR;
            return start_ts;
        }
 
        ts_t offset_y = secs % SEC_PER_YEAR;
        ts_t year_start_ts = start_ts + secs - offset_y;
        if (offset_y <  SEC_PER_YEAR * 2) {
            return year_start_ts;
        }
        else
        if (offset_y < (SEC_PER_YEAR * 3)) {
            return year_start_ts + SEC_PER_YEAR;
        }
 
        return start_ts + SEC_PER_LEAP_YEAR;
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t start_of_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return sec_to_ms(start_of_year(ms_to_sec<ts_t>(ts_ms)));
    }

    TIME_SHIELD_CONSTEXPR inline ts_t end_of_year(ts_t ts = time_shield::ts()) {
        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_t>(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<size_t>(ts);
        return static_cast<T>((is_leap_year(ts) && dy >= JAN_AND_FEB_DAY_LEAP_YEAR) ? TABLE_MONTH_OF_YEAR[dy - 1] : TABLE_MONTH_OF_YEAR[dy]);
    }

    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline T day_of_month(ts_t ts = time_shield::ts()) {
        constexpr int JAN_AND_FEB_DAY_LEAP_YEAR = 60;
        // таблица для обычного года, не високосного
        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<size_t>(ts);
        if(is_leap_year(ts)) {
            if(dy == JAN_AND_FEB_DAY_LEAP_YEAR) return TABLE_DAY_OF_YEAR[dy - 1] + 1;
            if(dy > JAN_AND_FEB_DAY_LEAP_YEAR) return TABLE_DAY_OF_YEAR[dy - 1];
        }
        return TABLE_DAY_OF_YEAR[dy];
    }

    template<class T1 = int, class T2 = year_t, class T3 = int>
    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<int>(ts);
        if (month == FEB) {
            return is_leap_year(ts) ? 29 : 28;
        }
        return num_days[month];
    }

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

    template<class T = Weekday>
    constexpr T weekday_of_ts_ms(ts_ms_t ts_ms) {
        return weekday_of_ts<T>(ms_to_sec<ts_t>(ts_ms));
    }

    template<class T = Weekday>
    constexpr T get_weekday_from_ts(ts_t ts) noexcept {
        return weekday_of_ts<T>(ts);
    }

    template<class T = Weekday>
    constexpr T get_weekday_from_ts_ms(ts_ms_t ts_ms) {
        return weekday_of_ts_ms<T>(ts_ms);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t start_of_month(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) - (day_of_month(ts) - 1) * SEC_PER_DAY;
    }

    TIME_SHIELD_CONSTEXPR inline ts_t end_of_month(ts_t ts = time_shield::ts()) {
        return end_of_day(ts) + (num_days_in_month_ts(ts) - day_of_month(ts)) * SEC_PER_DAY;
    }

    TIME_SHIELD_CONSTEXPR inline ts_t last_sunday_of_month(ts_t ts = time_shield::ts()) {
        return end_of_month(ts) - weekday_of_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_week(ts_t ts = time_shield::ts()) {
        return start_of_day(ts) - weekday_of_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 - weekday_of_ts(ts)) * SEC_PER_DAY - 1;
    }

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

    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_t>(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_t>(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;
    }

    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 hour_of_day(ts_t ts = time_shield::ts()) noexcept {
        return ((ts / SEC_PER_HOUR) % HOURS_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;
    }

 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_DATE_TIME_CONVERSIONS_HPP_INCLUDED