unix_time_conversions.hpp

Go to the documentation of this file.

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

 
#include "config.hpp"
#include "constants.hpp"
#include "detail/fast_date.hpp"
#include "time_unit_conversions.hpp"
#include "time_utils.hpp"
#include "types.hpp"
 
namespace time_shield {

 
    namespace legacy {

        template<class T = year_t>
        TIME_SHIELD_CONSTEXPR T years_since_epoch(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;
        }
 
    } // namespace legacy

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR T years_since_epoch(ts_t ts) noexcept {
        const detail::DaySplit split = detail::split_unix_day(ts);
        const int64_t year = detail::fast_year_from_days_constexpr(split.days);
        return static_cast<T>(year - UNIX_EPOCH);
    }
 
    namespace legacy {

        template<class Year, class Month, class Day>
        TIME_SHIELD_CONSTEXPR inline dse_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<dse_t>(era * 146097 + doe - 719468);
        }
 
    } // namespace legacy

    template<class Year, class Month, class Day>
    TIME_SHIELD_CONSTEXPR inline dse_t date_to_unix_day(
            Year year,
            Month month,
            Day day) noexcept {
        return static_cast<dse_t>(
            detail::fast_days_from_date_constexpr(
                static_cast<int64_t>(year),
                static_cast<int>(month),
                static_cast<int>(day)));
    }

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

    template<class T = dse_t>
    constexpr T days_since_epoch_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch<T>(ms_to_sec<ts_t>(t_ms));
    }

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

    template<class T = ts_t>
    constexpr T unix_day_to_ts(dse_t unix_day) noexcept {
        return unix_day * SEC_PER_DAY;
    }

    template<class T = ts_t>
    constexpr T unix_day_to_ts_ms(dse_t unix_day) noexcept {
        return unix_day * MS_PER_DAY;
    }

    template<class T = ts_t>
    constexpr T end_of_day_from_unix_day(dse_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(dse_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(dse_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(dse_t unix_day) noexcept {
        return unix_day * MS_PER_DAY + MS_PER_DAY;
    }

    template<class T = int64_t>
    constexpr T min_since_epoch(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 static_cast<T>(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_t>(ts_ms));
    }

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

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

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

 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_UNIX_TIME_CONVERSIONS_HPP_INCLUDED