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 "time_unit_conversions.hpp"
#include "time_utils.hpp"
#include "types.hpp"
 
namespace time_shield {


    template<class T = year_t>
    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;
    }

    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 days_since_epoch(ts_t ts = time_shield::ts()) noexcept {
        return ts / SEC_PER_DAY;
    }

    template<class T = uday_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 (stop - start) / SEC_PER_DAY;
    }

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

    template<class T = ts_t>
    constexpr T unix_day_to_ts_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 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 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 (ts % SEC_PER_MIN);
    }

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

 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_UNIX_TIME_CONVERSIONS_HPP_INCLUDED