validation.hpp

Go to the documentation of this file.

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

 
#include "config.hpp"
#include "types.hpp"
#include "constants.hpp"
#include "time_zone_struct.hpp"
 
namespace time_shield {


    template<class T = year_t>
    constexpr bool is_leap_year_date(T year) noexcept {
        return ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0));
    }

    template<class T = year_t>
    constexpr bool check_leap_year(T year) noexcept {
        return is_leap_year_date(year);
    }

    template<class T = year_t>
    constexpr bool leap_year(T year) noexcept {
        return is_leap_year_date(year);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR bool is_leap_year_ts(ts_t 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 = -((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 is_leap_year_date(y);
    }

    TIME_SHIELD_CONSTEXPR bool leap_year_ts(ts_t ts) {
        return is_leap_year_ts(ts);
    }

    TIME_SHIELD_CONSTEXPR bool check_leap_year_ts(ts_t ts) {
        return is_leap_year_ts(ts);
    }

    TIME_SHIELD_CONSTEXPR bool is_leap_year(ts_t ts) {
        return is_leap_year_ts(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_time_zone(
            T hour,
            T min) noexcept {
        if (hour < 0 || hour > 23) return false;
        if (min < 0 || min > 59) return false;
        return true;
    }

    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_tz(
            T hour,
            T min) {
        return is_valid_time_zone(hour, min);
    }
 
//------------------------------------------------------------------------------

    template<class T = TimeZoneStruct>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_time_zone_offset(
            const T& time_zone) noexcept {
        return is_valid_time_zone(time_zone.hour, time_zone.min);
    }

    template<class T = TimeZoneStruct>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_time_zone(
            const T& time_zone) {
        return is_valid_time_zone_offset(time_zone);
    }

    template<class T = TimeZoneStruct>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_tz(
            const T& time_zone) {
        return is_valid_time_zone_offset(time_zone);
    }
 
//------------------------------------------------------------------------------

    template<class T1 = int, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_time(
            T1 hour,
            T1 min,
            T1 sec,
            T2 ms = 0) noexcept {
        if (hour < 0 || hour > 23) return false;
        if (min < 0 || min > 59) return false;
        if (sec < 0 || sec > 59) return false;
        if (ms < 0 || ms > 999) return false;
        return true;
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_time(
            const T& time) noexcept {
        return is_valid_time(time.hour, time.min, time.sec, time.ms);
    }

    template<class T1 = year_t, class T2 = int>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_date(
            T1 year,
            T2 month,
            T2 day) noexcept {
        if (day > 31 && year <= 31) {
            return is_valid_date((T1)day, month, (T2)year);
        }
        if (year > MAX_YEAR) return false;
        if (month < 1 || month > 12) return false;
        if (day < 1 || day > 31) return false;
        if (month == FEB) {
            const bool is_leap_year = is_leap_year_date(year);
            if (is_leap_year && day > 29) return false;
            if (!is_leap_year && day > 28) return false;
        } else {
            switch(month) {
            case 4:
            case 6:
            case 9:
            case 11:
                if (day > 30) return false;
            default:
                break;
            };
        }
        return true;
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_date(const T& date) noexcept {
        return is_valid_date(date.year, date.mon, date.day);
    }

    template<class T1 = year_t, class T2 = int, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_date_time(
            T1 year,
            T2 month,
            T2 day,
            T2 hour  = 0,
            T2 min   = 0,
            T2 sec   = 0,
            T3 ms    = 0) noexcept {
        if (!is_valid_date(year, month, day)) return false;
        if (!is_valid_time(hour, min, sec, ms)) return false;
        return true;
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline bool is_valid_date_time(
            const T &date_time) noexcept {
        if (!is_valid_date(date_time)) return false;
        if (!is_valid_time(date_time)) return false;
        return true;
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool is_day_off(ts_t ts) noexcept {
        const int wd = ((ts / SEC_PER_DAY + THU) % DAYS_PER_WEEK);
        return (wd == SUN || wd == SAT);
    }

    TIME_SHIELD_CONSTEXPR inline bool is_weekend(ts_t ts) noexcept {
        return is_day_off(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T = uday_t>
    TIME_SHIELD_CONSTEXPR inline bool is_day_off_unix_day(T unix_day) noexcept {
        const int wd = (unix_day + THU) % DAYS_PER_WEEK;
        return (wd == SUN || wd == SAT);
    }

    template<class T = uday_t>
    TIME_SHIELD_CONSTEXPR inline bool is_weekend_unix_day(T unix_day) noexcept {
        return is_day_off_unix_day(unix_day);
    }

 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_VALIDATION_HPP_INCLUDED