time_conversion_aliases.hpp

Go to the documentation of this file.

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

 
#include <string>
 
namespace time_shield {


    template<class T = year_t>
    constexpr T unix_year(ts_t ts) noexcept {
        return years_since_epoch<T>(ts);
    }

    template<class T = year_t>
    constexpr T to_unix_year(ts_t ts) noexcept {
        return years_since_epoch<T>(ts);
    }
    
    template<class T = year_t>
    constexpr T get_unix_year(ts_t ts) noexcept {
        return years_since_epoch<T>(ts);
    }
 
//------------------------------------------------------------------------------
 

    template<class T = uday_t>
    constexpr T get_unixday(ts_t ts = time_shield::ts()) noexcept {
        return days_since_epoch<T>(ts);
    }
 

    template<class T = uday_t>
    constexpr T unix_day(ts_t ts = time_shield::ts()) noexcept {
        return days_since_epoch<T>(ts);
    }
 

    template<class T = uday_t>
    constexpr T unixday(ts_t ts = time_shield::ts()) noexcept {
        return days_since_epoch<T>(ts);
    }
 

    template<class T = uday_t>
    constexpr T uday(ts_t ts = time_shield::ts()) noexcept {
        return days_since_epoch<T>(ts);
    }
    
    template<class T = uday_t>
    constexpr T get_unix_day(ts_t ts = time_shield::ts()) noexcept {
        return days_since_epoch<T>(ts);
    }
    
//------------------------------------------------------------------------------
 

    template<class T = uday_t>
    constexpr T get_unixday_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch_ms<T>(t_ms);
    }
 

    template<class T = uday_t>
    constexpr T unix_day_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch_ms<T>(t_ms);
    }
 

    template<class T = uday_t>
    constexpr T unixday_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch_ms<T>(t_ms);
    }
 

    template<class T = uday_t>
    constexpr T uday_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch_ms<T>(t_ms);
    }

    template<class T = uday_t>
    constexpr T get_unix_day_ms(ts_ms_t t_ms = time_shield::ts_ms()) noexcept {
        return days_since_epoch_ms<T>(t_ms);
    }
    
//------------------------------------------------------------------------------

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

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

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

    template<class T = ts_t>
    constexpr T start_of_day_from_unix_day(uday_t unix_day) noexcept {
        return unix_day_to_ts<T>(unix_day);
    }
    
//------------------------------------------------------------------------------

    template<class T = ts_t>
    constexpr T unix_day_to_timestamp_ms(uday_t unix_day) noexcept {
        return unix_day_to_ts_ms(unix_day);
    }

    template<class T = ts_t>
    constexpr T unixday_to_ts_ms(uday_t unix_day) noexcept {
        return unix_day_to_ts_ms(unix_day);
    }

    template<class T = ts_t>
    constexpr T uday_to_ts_ms(uday_t unix_day) noexcept {
        return unix_day_to_ts_ms(unix_day);
    }

    template<class T = ts_t>
    constexpr T start_of_day_from_unix_day_ms(uday_t unix_day) noexcept {
        return unix_day_to_ts_ms(unix_day);
    }
    
//------------------------------------------------------------------------------

    template<class T = ts_t>
    constexpr T next_day_from_unix_day(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day(unix_day);
    }

    template<class T = ts_t>
    constexpr T next_day_unix_day(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day(unix_day);
    }

    template<class T = ts_t>
    constexpr T next_day_unixday(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day(unix_day);
    }
    
//------------------------------------------------------------------------------

    template<class T = ts_ms_t>
    constexpr T next_day_from_unix_day_ms(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day_ms(unix_day);
    }

    template<class T = ts_ms_t>
    constexpr T next_day_unix_day_ms(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day_ms(unix_day);
    }

    template<class T = ts_ms_t>
    constexpr T next_day_unixday_ms(uday_t unix_day) noexcept {
        return start_of_next_day_from_unix_day_ms(unix_day);
    }
    
//------------------------------------------------------------------------------

    template<class T = int64_t>
    constexpr T minutes_since_epoch(ts_t ts = time_shield::ts()) {
        return min_since_epoch<T>(ts);
    }

    template<class T = int64_t>
    constexpr T unix_min(ts_t ts = time_shield::ts()) {
        return min_since_epoch<T>(ts);
    }

    template<class T = int64_t>
    constexpr T to_unix_min(ts_t ts = time_shield::ts()) {
        return min_since_epoch<T>(ts);
    }

    template<class T = int64_t>
    constexpr T umin(ts_t ts = time_shield::ts()) {
        return min_since_epoch<T>(ts);
    }
    
    template<class T = int64_t>
    constexpr T get_unix_min(ts_t ts = time_shield::ts()) {
        return min_since_epoch<T>(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T>
    TIME_SHIELD_CONSTEXPR inline auto dt_to_ts(const T& date_time)
            -> decltype(dt_to_timestamp(date_time)) {
        return dt_to_timestamp(date_time);
    }

    TIME_SHIELD_CONSTEXPR inline auto tm_to_ts(const std::tm* timeinfo)
            -> decltype(tm_to_timestamp(timeinfo)) {
        return tm_to_timestamp(timeinfo);
    }
 
//------------------------------------------------------------------------------

    template<class T = int>
    TIME_SHIELD_CONSTEXPR inline T h24_to_h12(T hour) noexcept {
        return hour24_to_12(hour);
    }
    
//------------------------------------------------------------------------------

    template<class T1, class T2 = ts_t>
    T1 to_dt(T2 ts) {
        return to_date_time(ts);
    }
    
    template<class T1, class T2 = ts_t>
    T1 to_dt_struct(T2 ts) {
        return to_date_time(ts);
    }

    inline auto to_dt(ts_t ts)
            -> decltype(to_date_time(ts)) {
        return to_date_time(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T>
    inline T to_dt_ms(ts_ms_t ts) {
        return to_date_time_ms<T>(ts);
    }
    
    template<class T>
    inline T to_dt_struct_ms(ts_ms_t ts) {
        return to_date_time_ms<T>(ts);
    }

    inline auto to_dt_ms(ts_ms_t ts_ms)
            -> decltype(to_date_time_ms<DateTimeStruct>(ts_ms)) {
        return to_date_time_ms<DateTimeStruct>(ts_ms);
    }
 
//------------------------------------------------------------------------------
 

    TIME_SHIELD_CONSTEXPR inline ts_t ts(year_t year, int month, int day) {
        return to_timestamp(year, month, day);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t ts(year_t year, int month, int day, int hour) {
        return to_timestamp(year, month, day, hour);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t ts(year_t year, int month, int day, int hour, int min) {
        return to_timestamp(year, month, day, hour, min);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t ts(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp(year, month, day, hour, min, sec);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_ts(year_t year, int month, int day) {
        return to_timestamp(year, month, day);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_ts(year_t year, int month, int day, int hour) {
        return to_timestamp(year, month, day, hour);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_ts(year_t year, int month, int day, int hour, int min) {
        return to_timestamp(year, month, day, hour, min);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_ts(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp(year, month, day, hour, min, sec);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_timestamp(year_t year, int month, int day) {
        return to_timestamp(year, month, day);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_timestamp(year_t year, int month, int day, int hour) {
        return to_timestamp(year, month, day, hour);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_timestamp(year_t year, int month, int day, int hour, int min) {
        return to_timestamp(year, month, day, hour, min);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t get_timestamp(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp(year, month, day, hour, min, sec);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(year_t year, int month, int day) {
        return to_timestamp(year, month, day);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(year_t year, int month, int day, int hour) {
        return to_timestamp(year, month, day, hour);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(year_t year, int month, int day, int hour, int min) {
        return to_timestamp(year, month, day, hour, min);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp(year, month, day, hour, min, sec);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(year_t year, int month, int day) {
        return to_timestamp(year, month, day);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(year_t year, int month, int day, int hour) {
        return to_timestamp(year, month, day, hour);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(year_t year, int month, int day, int hour, int min) {
        return to_timestamp(year, month, day, hour, min);
    }
 

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp(year, month, day, hour, min, sec);
    }
 
//------------------------------------------------------------------------------

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t ts(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(
            const T& date_time) {
        return dt_to_timestamp(date_time);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t ts(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t get_ts(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t timestamp(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t get_timestamp(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t ts_from_tm(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp(const std::tm* timeinfo) {
        return tm_to_timestamp(timeinfo);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_ms_t ts_ms(year_t year, int month, int day) {
        return to_timestamp_ms(year, month, day);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t ts_ms(year_t year, int month, int day, int hour) {
        return to_timestamp_ms(year, month, day, hour);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t ts_ms(year_t year, int month, int day, int hour, int min) {
        return to_timestamp_ms(year, month, day, hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t ts_ms(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp_ms(year, month, day, hour, min, sec);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t ts_ms(year_t year, int month, int day, int hour, int min, int sec, int ms) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_ts_ms(year_t year, int month, int day) {
        return to_timestamp_ms(year, month, day);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_ts_ms(year_t year, int month, int day, int hour) {
        return to_timestamp_ms(year, month, day, hour);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_ts_ms(year_t year, int month, int day, int hour, int min) {
        return to_timestamp_ms(year, month, day, hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_ts_ms(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp_ms(year, month, day, hour, min, sec);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_ts_ms(year_t year, int month, int day, int hour, int min, int sec, int ms) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_timestamp_ms(year_t year, int month, int day) {
        return to_timestamp_ms(year, month, day);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_timestamp_ms(year_t year, int month, int day, int hour) {
        return to_timestamp_ms(year, month, day, hour);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_timestamp_ms(year_t year, int month, int day, int hour, int min) {
        return to_timestamp_ms(year, month, day, hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_timestamp_ms(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp_ms(year, month, day, hour, min, sec);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t get_timestamp_ms(year_t year, int month, int day, int hour, int min, int sec, int ms) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t timestamp_ms(year_t year, int month, int day) {
        return to_timestamp_ms(year, month, day);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t timestamp_ms(year_t year, int month, int day, int hour) {
        return to_timestamp_ms(year, month, day, hour);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t timestamp_ms(year_t year, int month, int day, int hour, int min) {
        return to_timestamp_ms(year, month, day, hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t timestamp_ms(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp_ms(year, month, day, hour, min, sec);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t timestamp_ms(year_t year, int month, int day, int hour, int min, int sec, int ms) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_ts_ms(year_t year, int month, int day) {
        return to_timestamp_ms(year, month, day);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_ts_ms(year_t year, int month, int day, int hour) {
        return to_timestamp_ms(year, month, day, hour);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_ts_ms(year_t year, int month, int day, int hour, int min) {
        return to_timestamp_ms(year, month, day, hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_ts_ms(year_t year, int month, int day, int hour, int min, int sec) {
        return to_timestamp_ms(year, month, day, hour, min, sec);
    }

    TIME_SHIELD_CONSTEXPR inline ts_ms_t to_ts_ms(year_t year, int month, int day, int hour, int min, int sec, int ms) {
        return to_timestamp_ms(year, month, day, hour, min, sec, ms);
    }
 
//------------------------------------------------------------------------------

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline auto dt_to_ts_ms(const T& date_time)
            -> decltype(dt_to_timestamp_ms(date_time)) {
        return dt_to_timestamp_ms(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t to_ts_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t ts_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline ts_t timestamp_ms(
            const T& date_time) {
        return dt_to_timestamp_ms(date_time);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t to_timestamp_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline auto tm_to_ts_ms(const std::tm *timeinfo)
            -> decltype(tm_to_timestamp_ms(timeinfo)) {
        return tm_to_timestamp_ms(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t to_ts_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t ts_ms(
            const std::tm *timeinfo) {
        return tm_to_timestamp_ms(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline 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>
    constexpr fts_t to_fts(T1 year, T2 month, T2 day, T2 hour = 0, T2 min = 0, T2 sec = 0, T3 ms = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }

    template<class T1 = year_t, class T2 = int, class T3 = int>
    constexpr fts_t fts(T1 year, T2 month, T2 day, T2 hour = 0, T2 min = 0, T2 sec = 0, T3 ms = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }

    template<class T1 = year_t, class T2 = int, class T3 = int>
    constexpr fts_t ftimestamp(T1 year, T2 month, T2 day, T2 hour = 0, T2 min = 0, T2 sec = 0, T3 ms = 0) {
        return to_ftimestamp(year, month, day, hour, min, sec, ms);
    }
    
//------------------------------------------------------------------------------

    template<class T>
    constexpr fts_t to_ftimestamp(const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }

    template<class T>
    constexpr auto dt_to_fts(const T& date_time)
            -> decltype(dt_to_ftimestamp(date_time)) {
        return dt_to_ftimestamp(date_time);
    }

    template<class T>
    constexpr fts_t to_fts(const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }

    template<class T>
    constexpr fts_t fts(const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }

    template<class T>
    constexpr fts_t ftimestamp(const T& date_time) {
        return dt_to_ftimestamp(date_time);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline fts_t to_ftimestamp(const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline auto tm_to_fts(const std::tm* timeinfo)
            -> decltype(tm_to_ftimestamp(timeinfo)) {
        return tm_to_ftimestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline fts_t to_fts(const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
    
    TIME_SHIELD_CONSTEXPR inline fts_t fts(const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }

    TIME_SHIELD_CONSTEXPR inline fts_t ftimestamp(const std::tm* timeinfo) {
        return tm_to_ftimestamp(timeinfo);
    }
 
//------------------------------------------------------------------------------

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

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

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T year(ts_t ts = time_shield::ts()) {
        return year_of<T>(ts);
    }

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T to_year(ts_t ts = time_shield::ts()) {
        return year_of<T>(ts);
    }
    
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T get_year(ts_t ts = time_shield::ts()) {
        return year_of<T>(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return year_of_ms<T>(ts_ms);
    }

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T to_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return year_of_ms<T>(ts_ms);
    }
    
    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline T get_year_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return year_of_ms<T>(ts_ms);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t year_start(ts_t ts = time_shield::ts()) {
        return start_of_year(ts);
    }

    TIME_SHIELD_CONSTEXPR inline ts_t year_begin(ts_t ts = time_shield::ts()) {
        return start_of_year(ts);
    }
    
//------------------------------------------------------------------------------

    inline ts_ms_t year_start_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return start_of_year_ms(ts_ms);
    }

    inline ts_ms_t year_begin_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return start_of_year_ms(ts_ms);
    }
    
//------------------------------------------------------------------------------

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_t year_start_date(T year) {
        return start_of_year_date(year);
    }

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_t year_begin_date(T year) {
        return start_of_year_date(year);
    }
 
//------------------------------------------------------------------------------

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

    template<class T = year_t>
    TIME_SHIELD_CONSTEXPR inline ts_ms_t year_begin_date_ms(T year) {
        return start_of_year_date_ms(year);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t year_end(ts_t ts = time_shield::ts()) {
        return end_of_year(ts);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_ms_t year_end_ms(ts_ms_t ts_ms = time_shield::ts_ms()) {
        return end_of_year_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------

    template<class T1 = int, class T2 = year_t, class T3 = int>
    constexpr T1 days_in_month(T2 year, T3 month) noexcept {
        return num_days_in_month(year, month);
    }
    
//------------------------------------------------------------------------------

    template<class T1 = int>
    constexpr T1 num_days_in_month(ts_t ts = time_shield::ts()) noexcept {
        return num_days_in_month_ts(ts);
    }

    template<class T1 = int>
    constexpr T1 days_in_month(ts_t ts = time_shield::ts()) noexcept {
        return num_days_in_month_ts(ts);
    }
    
//------------------------------------------------------------------------------

    template<class T1 = int, class T2 = year_t>
    constexpr T1 days_in_year(T2 year) noexcept {
        return num_days_in_year(year);
    }
    
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T days_in_year_ts(ts_t ts = time_shield::ts()) {
        return num_days_in_year_ts(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t day_start(ts_t ts = time_shield::ts()) noexcept {
        return start_of_day(ts);
    }
    
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_t previous_day_start(ts_t ts = time_shield::ts(), T days = 1) noexcept {
        return start_of_prev_day(ts, days);
    }
    
//------------------------------------------------------------------------------
    
    constexpr ts_t day_start_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_day(ms_to_sec(ts_ms));
    }
    
    constexpr ts_t start_day_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_day(ms_to_sec(ts_ms));
    }
 
//------------------------------------------------------------------------------
    
    constexpr ts_ms_t day_start_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_day_ms(ts_ms);
    }
    
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_t next_day_start(ts_t ts, T days = 1) noexcept {
        return start_of_next_day(ts, days);
    }
    
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr ts_ms_t next_day_start_ms(ts_ms_t ts_ms, T days = 1) noexcept {
        return start_of_next_day_ms(ts_ms, days);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t day_end(ts_t ts = time_shield::ts()) noexcept {
        return end_of_day(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t day_end_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_day_sec(ts_ms);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_ms_t day_end_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_day_ms(ts_ms);
    }
    
//------------------------------------------------------------------------------

    template<class T1 = Weekday>
    constexpr T1 day_of_week(year_t year, int month, int day) {
        return day_of_week_date<T1>(year, month, day);
    }

    template<class T1 = Weekday>
    constexpr T1 day_of_week(year_t year, Month month, int day) {
        return day_of_week_date<T1>(year, static_cast<int>(month), day);
    }

    template<class T1 = Weekday>
    constexpr T1 get_weekday(year_t year, int month, int day) {
        return day_of_week_date<T1>(year, month, day);
    }

    template<class T1 = Weekday>
    constexpr T1 get_weekday(year_t year, Month month, int day) {
        return day_of_week_date<T1>(year, static_cast<int>(month), day);
    }

    template<class T1 = Weekday>
    constexpr T1 weekday(year_t year, int month, int day) {
        return day_of_week_date<T1>(year, month, day);
    }

    template<class T1 = Weekday>
    constexpr T1 weekday(year_t year, Month month, int day) {
        return day_of_week_date<T1>(year, static_cast<int>(month), day);
    }

    template<class T1 = Weekday>
    constexpr T1 dow(year_t year, int month, int day) {
        return day_of_week_date<T1>(year, month, day);
    }

    template<class T1 = Weekday>
    constexpr T1 dow(year_t year, Month month, int day) {
        return day_of_week_date<T1>(year, static_cast<int>(month), day);
    }
    
//------------------------------------------------------------------------------

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    TIME_SHIELD_CONSTEXPR inline T1 get_weekday_from_date(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 get_dow(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 dow_from_date(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 weekday_of(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 day_of_week_dt(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 day_of_week(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 dow(const T2& date) {
        return weekday_of_date<T1>(date);
    }

    template<class T1 = Weekday, class T2, typename std::enable_if<std::is_class<T2>::value, int>::type = 0>
    constexpr T1 wd(const T2& date) {
        return weekday_of_date<T1>(date);
    }
    
//------------------------------------------------------------------------------
 

    template<class T = Weekday, class U, typename std::enable_if<std::is_integral<U>::value, int>::type = 0>
    constexpr T day_of_week(U ts) noexcept {
        return weekday_of_ts<T>(ts);
    }

    template<class T = Weekday, class U, typename std::enable_if<std::is_integral<U>::value, int>::type = 0>
    constexpr T dow_ts(U ts) noexcept {
        return weekday_of_ts<T>(ts);
    }

    template<class T = Weekday, class U, typename std::enable_if<std::is_integral<U>::value, int>::type = 0>
    constexpr T get_dow_from_ts(U ts) noexcept {
        return weekday_of_ts<T>(ts);
    }

    template<class T = Weekday, class U, typename std::enable_if<std::is_integral<U>::value, int>::type = 0>
    constexpr T get_weekday_from_ts(U ts) noexcept {
        return weekday_of_ts<T>(ts);
    }
 
//------------------------------------------------------------------------------

    template<class T = Weekday, class U, typename std::enable_if<std::is_integral<U>::value, int>::type = 0>
    constexpr T wd_ts(U ts) noexcept {
        return weekday_of_ts<T>(ts);
    }
 
//------------------------------------------------------------------------------

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

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

    TIME_SHIELD_CONSTEXPR inline ts_t month_begin(ts_t ts = time_shield::ts()) {
        return start_of_month(ts);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t last_day_of_month(ts_t ts = time_shield::ts()) {
        return end_of_month(ts);
    }
    
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline ts_t final_sunday_of_month(ts_t ts = time_shield::ts()) {
        return last_sunday_of_month(ts);
    }
    
//------------------------------------------------------------------------------

    template<class T1 = int, class T2 = year_t, class T3 = int>
    TIME_SHIELD_CONSTEXPR inline T1 final_sunday_month_day(T2 year, T3 month) {
        return last_sunday_month_day(year, month);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t hour_begin(ts_t ts = time_shield::ts()) noexcept {
        return start_of_hour(ts);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t hour_begin_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_hour_sec(ts_ms);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_ms_t hour_begin_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return start_of_hour_ms(ts_ms);
    }
 
//------------------------------------------------------------------------------

    constexpr ts_t finish_of_hour(ts_t ts = time_shield::ts()) noexcept {
        return end_of_hour(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t finish_of_hour_sec(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_hour_sec(ts_ms);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_ms_t finish_of_hour_ms(ts_ms_t ts_ms = time_shield::ts_ms()) noexcept {
        return end_of_hour_ms(ts_ms);
    }
    
//------------------------------------------------------------------------------

    template<class T = int>
    constexpr T hour_in_day(ts_t ts = time_shield::ts()) noexcept {
        return hour_of_day(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t week_begin(ts_t ts = time_shield::ts()) {
        return start_of_week(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t finish_of_week(ts_t ts = time_shield::ts()) {
        return end_of_week(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t saturday_begin(ts_t ts = time_shield::ts()) {
        return start_of_saturday(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t min_begin(ts_t ts = time_shield::ts()) noexcept {
        return start_of_min(ts);
    }
    
//------------------------------------------------------------------------------

    constexpr ts_t finish_of_min(ts_t ts = time_shield::ts()) noexcept {
        return end_of_min(ts);
    }
 
//------------------------------------------------------------------------------

    TIME_SHIELD_CONSTEXPR inline bool workday(ts_t ts) noexcept {
        return is_workday(ts);
    }

    TIME_SHIELD_CONSTEXPR inline bool workday_ms(ts_ms_t ts_ms) noexcept {
        return is_workday_ms(ts_ms);
    }

    TIME_SHIELD_CONSTEXPR inline bool workday(year_t year, int month, int day) noexcept {
        return is_workday(year, month, day);
    }

    template<class T>
    TIME_SHIELD_CONSTEXPR inline tz_t tz_offset(const T& tz) noexcept {
        return to_tz_offset(tz);
    }

    TIME_SHIELD_CONSTEXPR inline tz_t offset_hm(int hour, int min = 0) noexcept {
        return tz_offset_hm(hour, min);
    }

    TIME_SHIELD_CONSTEXPR inline bool valid_tz_offset(tz_t off) noexcept {
        return is_valid_tz_offset(off);
    }

 
}; // namespace time_shield
 
#endif // _TIME_SHIELD_TIME_CONVERSIONS_ALIASES_HPP_INCLUDED