time_conversions.mqh

Go to the documentation of this file.

//+------------------------------------------------------------------+
//|                                             time_conversions.mqh |
//|                              Time Shield - MQL5 Time Conversions |
//|                                      Copyright 2025, NewYaroslav |
//|                   https://github.com/NewYaroslav/time-shield-cpp |
//+------------------------------------------------------------------+
#ifndef __TIME_SHIELD_TIME_CONVERSIONS_MQH__
#define __TIME_SHIELD_TIME_CONVERSIONS_MQH__

 
#property copyright "Copyright 2025, NewYaroslav"
#property link      "https://github.com/NewYaroslav/time-shield-cpp"
#property strict
 
#include "constants.mqh"
#include "date_time_struct.mqh"
#include "enums.mqh"
#include "validation.mqh"
#include "time_zone_struct.mqh"
 
namespace time_shield {


    int ns_of_sec(double ts) {
       double frac = ts - MathFloor(ts);
       return (int)MathRound(frac * NS_PER_SEC);
    }

    int us_of_sec(double ts) {
       double frac = ts - MathFloor(ts);
       return (int)MathRound(frac * US_PER_SEC);
    }

    int ms_of_sec(double ts) {
       double frac = ts - MathFloor(ts);
       return (int)MathRound(frac * MS_PER_SEC);
    }

    int ms_of_ts(long ts_ms) {
       return (int)(ts_ms % MS_PER_SEC);
    }
 
    //----------------------------------------------------------------------
    // Seconds <-> Milliseconds
    //----------------------------------------------------------------------

    long sec_to_ms(double sec) {
       return (long)MathRound(sec * MS_PER_SEC);
    }

    long ms_to_sec(long ms) {
       return ms / MS_PER_SEC;
    }

    double ms_to_fsec(long ms) {
       return (double)ms / (double)MS_PER_SEC;
    }
 
    //----------------------------------------------------------------------
    // Minutes <-> Milliseconds / Seconds
    //----------------------------------------------------------------------

    long min_to_ms(double min) {
       return (long)MathRound(min * MS_PER_MIN);
    }

    int ms_to_min(long ms) {
       return (int)(ms / MS_PER_MIN);
    }

    long min_to_sec(double min) {
       return (long)MathRound(min * SEC_PER_MIN);
    }

    int sec_to_min(long sec) {
       return (int)(sec / SEC_PER_MIN);
    }

    double min_to_fsec(double min) {
       return min * SEC_PER_MIN;
    }

    double sec_to_fmin(long sec) {
       return (double)sec / (double)SEC_PER_MIN;
    }
 
    //----------------------------------------------------------------------
    // Hours <-> Milliseconds / Seconds
    //----------------------------------------------------------------------

    long hour_to_ms(double hr) {
       return (long)MathRound(hr * MS_PER_HOUR);
    }

    int ms_to_hour(long ms) {
       return (int)(ms / MS_PER_HOUR);
    }

    long hour_to_sec(double hr) {
       return (long)MathRound(hr * SEC_PER_HOUR);
    }

    int sec_to_hour(long sec) {
       return (int)(sec / SEC_PER_HOUR);
    }

    double hour_to_fsec(double hr) {
       return hr * SEC_PER_HOUR;
    }

double sec_to_fhour(long sec) {
       return (double)sec / (double)SEC_PER_HOUR;
   }

    int hour24_to_12(int hour) {
       if(hour == 0 || hour > 12) return 12;
       return hour;
    }

    int h24_to_h12(int hour) { return hour24_to_12(hour); }
 
    //----------------------------------------------------------------------
    // Timestamp <-> Year
    //----------------------------------------------------------------------

    long get_unix_year(long ts) {
       const long BIAS_292277022000 = 9223371890843040000;
       const long BIAS_2000         = 946684800;
 
       long y    = MAX_YEAR;
       long secs = -((ts - BIAS_2000) - BIAS_292277022000);
 
       long n_400_years = secs / SEC_PER_400_YEARS;
       secs -= n_400_years * SEC_PER_400_YEARS;
       y    -= n_400_years * 400;
 
       long n_100_years = secs / SEC_PER_100_YEARS;
       secs -= n_100_years * SEC_PER_100_YEARS;
       y    -= n_100_years * 100;
 
       long n_4_years = secs / SEC_PER_4_YEARS;
       secs -= n_4_years * SEC_PER_4_YEARS;
       y    -= n_4_years * 4;
 
       long 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;
    }

    long unix_year(long ts) { return get_unix_year(ts); }

    long to_unix_year(long ts) { return get_unix_year(ts); }

    long get_year(long ts) {
       return get_unix_year(ts) + UNIX_EPOCH;
    }

    long year(long ts) { return get_year(ts); }

    long to_year(long ts) { return get_year(ts); }

    long get_year_ms(long ts_ms) {
       return get_year(ms_to_sec(ts_ms));
    }

    long year_ms(long ts_ms) { return get_year_ms(ts_ms); }

    long to_year_ms(long ts_ms) { return get_year_ms(ts_ms); }
 
    //----------------------------------------------------------------------
    // DateTime conversions
    //----------------------------------------------------------------------

    DateTimeStruct to_date_time(long ts) {
       MqlDateTime tmp; 
       TimeToStruct((datetime)ts, tmp);
       DateTimeStruct dt;
       dt.year = tmp.year;
       dt.mon  = tmp.mon;
       dt.day  = tmp.day;
       dt.hour = tmp.hour;
       dt.min  = tmp.min;
       dt.sec  = tmp.sec;
       dt.ms   = 0;
       return dt;
    }

    DateTimeStruct to_dt(long ts) { return to_date_time(ts); }

    MqlDateTime to_date_time_mql(long ts) {
       MqlDateTime dt;
       TimeToStruct((datetime)ts, dt);
       return dt;
    }

    MqlDateTime to_mql_dt(long ts) { return to_date_time_mql(ts); }

    DateTimeStruct to_date_time_ms(long ts_ms) {
       DateTimeStruct dt = to_date_time(ms_to_sec(ts_ms));
       dt.ms = ms_of_ts(ts_ms);
       return dt;
    }

    DateTimeStruct to_dt_ms(long ts_ms) { return to_date_time_ms(ts_ms); }

    long dt_to_timestamp(const DateTimeStruct &dt) {
       MqlDateTime tmp;
       tmp.year = (int)dt.year;
       tmp.mon  = dt.mon;
       tmp.day  = dt.day;
       tmp.hour = dt.hour;
       tmp.min  = dt.min;
       tmp.sec  = dt.sec;
       return (long)StructToTime(tmp);
    }

    long dt_to_timestamp(const MqlDateTime &dt) {
       return (long)StructToTime(dt);
    }

    long to_timestamp(const DateTimeStruct &dt) { return dt_to_timestamp(dt); }

    long to_timestamp(const MqlDateTime &dt) { return dt_to_timestamp(dt); }

    long to_timestamp(long year, int mon, int day, int hour=0, int min=0, int sec=0) {
       MqlDateTime dt;
       dt.year = (int)year;
       dt.mon  = mon;
       dt.day  = day;
       dt.hour = hour;
       dt.min  = min;
       dt.sec  = sec;
       return (long)StructToTime(dt);
    }

    long to_ts(long year, int mon, int day, int hour=0, int min=0, int sec=0) {
       return to_timestamp(year, mon, day, hour, min, sec);
    }

    long to_timestamp_ms(long year, int mon, int day, int hour=0, int min=0, int sec=0, int ms=0) {
       return sec_to_ms(to_timestamp(year, mon, day, hour, min, sec)) + ms;
    }

    long to_ts_ms(long year, int mon, int day, int hour=0, int min=0, int sec=0, int ms=0) {
       return to_timestamp_ms(year, mon, day, hour, min, sec, ms);
    }

    long ts_ms(long year, int mon, int day, int hour=0, int min=0, int sec=0, int ms=0) {
       return to_timestamp_ms(year, mon, day, hour, min, sec, ms);
    }

    long dt_to_timestamp_ms(const DateTimeStruct &dt) {
       return sec_to_ms(dt_to_timestamp(dt)) + dt.ms;
    }

    long dt_to_timestamp_ms(const MqlDateTime &dt) {
       return sec_to_ms(dt_to_timestamp(dt));
    }

    long to_timestamp_ms(const DateTimeStruct &dt) { return dt_to_timestamp_ms(dt); }

    long to_timestamp_ms(const MqlDateTime &dt) { return dt_to_timestamp_ms(dt); }

    double dt_to_ftimestamp(const DateTimeStruct &dt) {
       return (double)dt_to_timestamp(dt) + (double)dt.ms / (double)MS_PER_SEC;
    }

    double dt_to_ftimestamp(const MqlDateTime &dt) {
       return (double)dt_to_timestamp(dt);
    }

    double to_ftimestamp(const DateTimeStruct &dt) { return dt_to_ftimestamp(dt); }

    double to_ftimestamp(const MqlDateTime &dt) { return dt_to_ftimestamp(dt); }
 
    //----------------------------------------------------------------------
    // Start/End of intervals
    //----------------------------------------------------------------------

    long start_of_day(long ts) {
       return ts - (ts % SEC_PER_DAY);
    }

    long day_start(long ts) { return start_of_day(ts); }

    long start_of_prev_day(long ts, int days=1) {
       return start_of_day(ts) - days * SEC_PER_DAY;
    }

    long previous_day_start(long ts, int days=1) { return start_of_prev_day(ts, days); }

    long start_of_day_sec(long ts_ms) {
       return start_of_day(ms_to_sec(ts_ms));
    }

    long day_start_sec(long ts_ms) { return start_of_day_sec(ts_ms); }

    long start_of_day_ms(long ts_ms) {
       return ts_ms - (ts_ms % MS_PER_DAY);
    }

    long day_start_ms(long ts_ms) { return start_of_day_ms(ts_ms); }

    long start_of_next_day(long ts, int days=1) {
       return start_of_day(ts) + days * SEC_PER_DAY;
    }

    long next_day_start(long ts, int days=1) { return start_of_next_day(ts, days); }

    long start_of_next_day_ms(long ts_ms, int days=1) {
       return start_of_day_ms(ts_ms) + days * MS_PER_DAY;
    }

    long next_day_start_ms(long ts_ms, int days=1) { return start_of_next_day_ms(ts_ms, days); }

    long next_day(long ts, int days=1) {
       return ts + days * SEC_PER_DAY;
    }

    long next_day_ms(long ts_ms, int days=1) {
       return ts_ms + days * MS_PER_DAY;
    }

    long end_of_day(long ts) {
       return ts - (ts % SEC_PER_DAY) + SEC_PER_DAY - 1;
    }

    long day_end(long ts) { return end_of_day(ts); }

    long end_of_day_sec(long ts_ms) {
       return end_of_day(ms_to_sec(ts_ms));
    }

    long day_end_sec(long ts_ms) { return end_of_day_sec(ts_ms); }

    long end_of_day_ms(long ts_ms) {
       return ts_ms - (ts_ms % MS_PER_DAY) + MS_PER_DAY - 1;
    }

    long day_end_ms(long ts_ms) { return end_of_day_ms(ts_ms); }

    Weekday day_of_week_date(long year, int month, int day) {
       long a = (14 - month) / MONTHS_PER_YEAR;
       long y = year - a;
       long m = month + MONTHS_PER_YEAR * a - 2;
       long r = 7000 + day + y + (y / 4) - (y / 100) + (y / 400) + (31 * m) / MONTHS_PER_YEAR;
       return (Weekday)(r % DAYS_PER_WEEK);
    }

    Weekday get_weekday(long year, int month, int day) { return day_of_week_date(year, month, day); }

    Weekday day_of_week(long year, int month, int day) { return day_of_week_date(year, month, day); }

    Weekday get_weekday_from_date(const DateTimeStruct &dt) {
       return day_of_week_date(dt.year, dt.mon, dt.day);
    }

    Weekday get_weekday_from_date(const MqlDateTime &dt) {
       return day_of_week_date(dt.year, dt.mon, dt.day);
    }

    Weekday day_of_week_dt(const DateTimeStruct &dt) { return get_weekday_from_date(dt); }

    Weekday day_of_week(const DateTimeStruct &dt) { return get_weekday_from_date(dt); }

    Weekday day_of_week_dt(const MqlDateTime &dt) { return get_weekday_from_date(dt); }

    Weekday day_of_week(const MqlDateTime &dt) { return get_weekday_from_date(dt); }

    Weekday get_weekday_from_ts(long ts) {
       return (Weekday)((ts / SEC_PER_DAY + THU) % DAYS_PER_WEEK);
    }

    Weekday day_of_week(long ts) { return get_weekday_from_ts(ts); }

    Weekday get_weekday_from_ts_ms(long ts_ms) {
       return get_weekday_from_ts(ms_to_sec(ts_ms));
    }

    Weekday day_of_week_ms(long ts_ms) { return get_weekday_from_ts_ms(ts_ms); }

    long start_of_year(long ts) {
       MqlDateTime dt; TimeToStruct((datetime)ts, dt);
       dt.mon = 1; dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
       return (long)StructToTime(dt);
    }

    long end_of_year(long ts) {
       MqlDateTime dt; TimeToStruct((datetime)ts, dt);
       dt.year++; dt.mon = 1; dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
       return (long)StructToTime(dt) - 1;
    }

    long year_start(long ts) { return start_of_year(ts); }

    long year_begin(long ts) { return start_of_year(ts); }

    long start_of_year_ms(long ts_ms) {
       return sec_to_ms(start_of_year(ms_to_sec(ts_ms)));
    }

    long year_start_ms(long ts_ms) { return start_of_year_ms(ts_ms); }

    long year_begin_ms(long ts_ms) { return start_of_year_ms(ts_ms); }

    long start_of_year_date(long year) {
       if (year < 2100) {
          long year_diff     = year >= UNIX_EPOCH ? year - UNIX_EPOCH : UNIX_EPOCH - year;
          long year_start_ts = (year_diff / 4) * SEC_PER_4_YEARS;
          int year_remainder = (int)(year_diff % 4);
          long SEC_PER_YEAR_X2 = 2 * SEC_PER_YEAR;
          long SEC_PER_YEAR_V2 = SEC_PER_YEAR_X2 + SEC_PER_LEAP_YEAR;
          switch (year_remainder) {
             case 0: return year_start_ts;
             case 1: return year_start_ts + SEC_PER_YEAR;
             case 2: return year_start_ts + SEC_PER_YEAR_X2;
             default: return year_start_ts + SEC_PER_YEAR_V2;
          }
          return year_start_ts + SEC_PER_YEAR_V2;
       }
       return to_timestamp(year, 1, 1);
    }

    long year_start_date(long year) { return start_of_year_date(year); }

    long year_begin_date(long year) { return start_of_year_date(year); }

    long start_of_year_date_ms(long year) {
       return sec_to_ms(start_of_year_date(year));
    }

    long year_start_date_ms(long year) { return start_of_year_date_ms(year); }

    long year_begin_date_ms(long year) { return start_of_year_date_ms(year); }

    long end_of_year_ms(long ts_ms) {
       return sec_to_ms(end_of_year(ms_to_sec(ts_ms)));
    }

    long year_end_ms(long ts_ms) { return end_of_year_ms(ts_ms); }

    int day_of_year(long ts) {
       return (int)((ts - start_of_year(ts)) / SEC_PER_DAY) + 1;
    }

    Month month_of_year(long ts) {
       const int JAN_AND_FEB_DAY_LEAP_YEAR = 60;
       static const 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,
           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,
           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,
           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,
           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,
       };
       int dy = day_of_year(ts);
       if(is_leap_year(ts) && dy >= JAN_AND_FEB_DAY_LEAP_YEAR)
          return (Month)TABLE_MONTH_OF_YEAR[dy - 1];
       return (Month)TABLE_MONTH_OF_YEAR[dy];
    }

    int day_of_month(long ts) {
       const int JAN_AND_FEB_DAY_LEAP_YEAR = 60;
       static const 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,
           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,
           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,
       };
       int dy = day_of_year(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];
    }

    int num_days_in_month(long year, int month) {
       if(month > MONTHS_PER_YEAR || month < 0) return 0;
       static const int 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];
    }

    int days_in_month(long year, int month) { return num_days_in_month(year, month); }

    int num_days_in_month_ts(long ts) {
       static const int num_days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
       int month = month_of_year(ts);
       if(month == FEB) {
          return is_leap_year(ts) ? 29 : 28;
       }
       return num_days[month];
    }

    int num_days_in_month(long ts) { return num_days_in_month_ts(ts); }

    int days_in_month(long ts) { return num_days_in_month_ts(ts); }
 
    //----------------------------------------------------------------------
    // Workday boundary helpers
    //----------------------------------------------------------------------
 
    int first_workday_day(long year, int month) {
       int days = num_days_in_month(year, month);
       if(days <= 0) return 0;
       for(int day = 1; day <= days; ++day) {
          if(is_workday(year, month, day)) return day;
       }
       return 0;
    }
 
    int last_workday_day(long year, int month) {
       int days = num_days_in_month(year, month);
       if(days <= 0) return 0;
       for(int day = days; day >= 1; --day) {
          if(is_workday(year, month, day)) return day;
       }
       return 0;
    }
 
    int count_workdays_in_month(long year, int month) {
       int days = num_days_in_month(year, month);
       if(days <= 0) return 0;
       int total = 0;
       for(int day = 1; day <= days; ++day) {
          if(is_workday(year, month, day)) ++total;
       }
       return total;
    }
 
    int workday_index_in_month(long year, int month, int day) {
       if(!is_workday(year, month, day)) return 0;
       int days = num_days_in_month(year, month);
       if(days <= 0) return 0;
       int index = 0;
       for(int current = 1; current <= days; ++current) {
          if(is_workday(year, month, current)) {
             ++index;
             if(current == day) return index;
          }
       }
       return 0;
    }
 
    //----------------------------------------------------------------------
    // Workday boundary predicates
    //----------------------------------------------------------------------
 
    bool is_first_workday_of_month(long year, int month, int day) {
       return is_workday(year, month, day) && first_workday_day(year, month) == day;
    }
 
    bool is_within_first_workdays_of_month(long year, int month, int day, int count) {
       if(count <= 0) return false;
       int total = count_workdays_in_month(year, month);
       if(count > total) return false;
       int index = workday_index_in_month(year, month, day);
       return index > 0 && index <= count;
    }
 
    bool is_last_workday_of_month(long year, int month, int day) {
       return is_workday(year, month, day) && last_workday_day(year, month) == day;
    }
 
    bool is_within_last_workdays_of_month(long year, int month, int day, int count) {
       if(count <= 0) return false;
       int total = count_workdays_in_month(year, month);
       if(count > total) return false;
       int index = workday_index_in_month(year, month, day);
       return index > 0 && index >= (total - count + 1);
    }
 
    bool is_first_workday_of_month(const long ts) {
       return is_first_workday_of_month(get_year(ts), (int)month_of_year(ts), day_of_month(ts));
    }
 
    bool is_within_first_workdays_of_month(const long ts, int count) {
       return is_within_first_workdays_of_month(get_year(ts), (int)month_of_year(ts), day_of_month(ts), count);
    }
 
    bool is_last_workday_of_month(const long ts) {
       return is_last_workday_of_month(get_year(ts), (int)month_of_year(ts), day_of_month(ts));
    }
 
    bool is_within_last_workdays_of_month(const long ts, int count) {
       return is_within_last_workdays_of_month(get_year(ts), (int)month_of_year(ts), day_of_month(ts), count);
    }
 
    bool is_first_workday_of_month_ms(const long ts_ms) {
       return is_first_workday_of_month(ms_to_sec(ts_ms));
    }
 
    bool is_within_first_workdays_of_month_ms(const long ts_ms, int count) {
       return is_within_first_workdays_of_month(ms_to_sec(ts_ms), count);
    }
 
    bool is_last_workday_of_month_ms(const long ts_ms) {
       return is_last_workday_of_month(ms_to_sec(ts_ms));
    }
 
    bool is_within_last_workdays_of_month_ms(const long ts_ms, int count) {
       return is_within_last_workdays_of_month(ms_to_sec(ts_ms), count);
    }

    int num_days_in_year(long year) {
       if (is_leap_year_date(year)) return (int)DAYS_PER_LEAP_YEAR;
       return (int)DAYS_PER_YEAR;
    }

    int days_in_year(long year) { return num_days_in_year(year); }

    int num_days_in_year_ts(long ts) {
       if(is_leap_year_ts(ts)) return (int)DAYS_PER_LEAP_YEAR;
       return (int)DAYS_PER_YEAR;
    }

    int days_in_year_ts(long ts) { return num_days_in_year_ts(ts); }

    long start_of_month(long ts) {
       return start_of_day(ts) - (day_of_month(ts) - 1) * SEC_PER_DAY;
    }

    long month_begin(long ts) { return start_of_month(ts); }

    long end_of_month(long ts) {
       return end_of_day(ts) + (num_days_in_month(ts) - day_of_month(ts)) * SEC_PER_DAY;
    }

    long last_day_of_month(long ts) { return end_of_month(ts); }

    long last_sunday_of_month(long ts) {
       return end_of_month(ts) - day_of_week(ts) * SEC_PER_DAY;
    }

    long final_sunday_of_month(long ts) { return last_sunday_of_month(ts); }

    int last_sunday_month_day(long year, int month) {
       int days = num_days_in_month(year, month);
       return days - day_of_week_date(year, month, days);
    }

    int final_sunday_month_day(long year, int month) { return last_sunday_month_day(year, month); }

    long start_of_hour(long ts) {
       return ts - (ts % SEC_PER_HOUR);
    }

    long hour_begin(long ts) { return start_of_hour(ts); }

    long start_of_hour_sec(long ts_ms) {
       return start_of_hour(ms_to_sec(ts_ms));
    }

    long hour_begin_sec(long ts_ms) { return start_of_hour_sec(ts_ms); }

    long start_of_hour_ms(long ts_ms) {
       return ts_ms - (ts_ms % MS_PER_HOUR);
    }

    long hour_begin_ms(long ts_ms) { return start_of_hour_ms(ts_ms); }

    long end_of_hour(long ts) {
       return ts - (ts % SEC_PER_HOUR) + SEC_PER_HOUR - 1;
    }

    long finish_of_hour(long ts) { return end_of_hour(ts); }

    long end_of_hour_sec(long ts_ms) {
       return end_of_hour(ms_to_sec(ts_ms));
    }

    long finish_of_hour_sec(long ts_ms) { return end_of_hour_sec(ts_ms); }

    long end_of_hour_ms(long ts_ms) {
       return ts_ms - (ts_ms % MS_PER_HOUR) + MS_PER_HOUR - 1;
    }

    long finish_of_hour_ms(long ts_ms) { return end_of_hour_ms(ts_ms); }

    int hour_of_day(long ts) {
       return (int)((ts / SEC_PER_HOUR) % HOURS_PER_DAY);
    }

    int hour_in_day(long ts) { return hour_of_day(ts); }

    long start_of_week(long ts) {
       return start_of_day(ts) - day_of_week(ts) * SEC_PER_DAY;
    }

    long week_begin(long ts) { return start_of_week(ts); }

    long end_of_week(long ts) {
       return start_of_day(ts) + (DAYS_PER_WEEK - day_of_week(ts)) * SEC_PER_DAY - 1;
    }

    long finish_of_week(long ts) { return end_of_week(ts); }

    long start_of_saturday(long ts) {
       return start_of_day(ts) + (SAT - day_of_week(ts)) * SEC_PER_DAY;
    }

    long saturday_begin(long ts) { return start_of_saturday(ts); }

    long start_of_min(long ts) {
       return ts - (ts % SEC_PER_MIN);
    }

    long min_begin(long ts) { return start_of_min(ts); }

    long end_of_min(long ts) {
       return ts - (ts % SEC_PER_MIN) + SEC_PER_MIN - 1;
    }

    long finish_of_min(long ts) { return end_of_min(ts); }

    int min_of_day(long ts) {
       return (int)((ts / SEC_PER_MIN) % MIN_PER_DAY);
    }

    int min_of_hour(long ts) {
       return (int)((ts / SEC_PER_MIN) % MIN_PER_HOUR);
    }

    int min_in_hour(long ts) { return min_of_hour(ts); }

    long start_of_period(int p, long ts) {
       return ts - (ts % p);
    }

    long end_of_period(int p, long ts) {
       return ts - (ts % p) + p - 1;
    }
 
    //----------------------------------------------------------------------
    // UNIX day and minute helpers
    //----------------------------------------------------------------------

    long date_to_unix_day(const long year, const int month, const int day) {
       const long adj_y = year - (month <= 2 ? 1 : 0);
       const long adj_m = month <= 2 ? month + 9 : month - 3;
       const long era = (adj_y >= 0 ? adj_y : adj_y - 399) / 400;
       const long yoe = adj_y - era * 400;
       const long doy = (153 * adj_m + 2) / 5 + day - 1;
       const long doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
       return era * 146097 + doe - 719468;
    }

    long get_unix_day(long ts) {
       return ts / SEC_PER_DAY;
    }

    long unix_day(long ts) { return get_unix_day(ts); }

    long get_unixday(long ts) { return get_unix_day(ts); }

    long unixday(long ts) { return get_unix_day(ts); }

    long uday(long ts) { return get_unix_day(ts); }

    int get_days_difference(long start, long stop) {
       return (int)((stop - start) / SEC_PER_DAY);
    }

    int get_days(long start, long stop) { return get_days_difference(start, stop); }

    int days(long start, long stop) { return get_days_difference(start, stop); }

    long get_unix_day_ms(long ts_ms) {
       return get_unix_day(ms_to_sec(ts_ms));
    }

    long unix_day_ms(long ts_ms) { return get_unix_day_ms(ts_ms); }

    long get_unixday_ms(long ts_ms) { return get_unix_day_ms(ts_ms); }

    long unixday_ms(long ts_ms) { return get_unix_day_ms(ts_ms); }

    long uday_ms(long ts_ms) { return get_unix_day_ms(ts_ms); }

    long unix_day_to_timestamp(long uday) {
       return uday * SEC_PER_DAY;
    }

    long unix_day_to_ts(long uday) { return unix_day_to_timestamp(uday); }

    long unixday_to_ts(long uday) { return unix_day_to_timestamp(uday); }

    long uday_to_ts(long uday) { return unix_day_to_timestamp(uday); }

    long start_of_day_from_unix_day(long uday) { return unix_day_to_timestamp(uday); }

    long unix_day_to_timestamp_ms(long uday) {
       return uday * MS_PER_DAY;
    }

    long unix_day_to_ts_ms(long uday) { return unix_day_to_timestamp_ms(uday); }

    long unixday_to_ts_ms(long uday) { return unix_day_to_timestamp_ms(uday); }

    long uday_to_ts_ms(long uday) { return unix_day_to_timestamp_ms(uday); }

    long start_of_day_from_unix_day_ms(long uday) { return unix_day_to_timestamp_ms(uday); }

    long end_of_day_from_unix_day(long uday) {
       return uday * SEC_PER_DAY + SEC_PER_DAY - 1;
    }

    long end_of_day_from_unix_day_ms(long uday) {
       return uday * MS_PER_DAY + MS_PER_DAY - 1;
    }

    long eod_from_unix_day(long uday) { return end_of_day_from_unix_day(uday); }

    long eod_from_unix_day_ms(long uday) { return end_of_day_from_unix_day_ms(uday); }

    long start_of_next_day_from_unix_day(long uday) {
       return uday * SEC_PER_DAY + SEC_PER_DAY;
    }

    long start_of_next_day_from_unix_day_ms(long uday) {
       return uday * MS_PER_DAY + MS_PER_DAY;
    }

    long next_day_unix_day(long uday) { return start_of_next_day_from_unix_day(uday); }

    long next_day_unixday(long uday) { return start_of_next_day_from_unix_day(uday); }

    long next_day_unix_day_ms(long uday) { return start_of_next_day_from_unix_day_ms(uday); }

    long next_day_unixday_ms(long uday) { return start_of_next_day_from_unix_day_ms(uday); }

    long next_day_from_unix_day(long uday) { return start_of_next_day_from_unix_day(uday); }

    long get_unix_min(long ts) {
       return ts / SEC_PER_MIN;
    }

    long unix_min(long ts) { return get_unix_min(ts); }

    long to_unix_min(long ts) { return get_unix_min(ts); }

    long umin(long ts) { return get_unix_min(ts); }

    int sec_of_day(long ts) {
       return (int)(ts % SEC_PER_DAY);
    }

    int sec_of_day_ms(long ts_ms) {
       return sec_of_day(ms_to_sec(ts_ms));
    }

    int sec_of_day(int hour, int min, int sec) {
       return hour * (int)SEC_PER_HOUR + min * (int)SEC_PER_MIN + sec;
    }

    TimeZoneStruct to_time_zone(int offset) {
       return to_time_zone_struct(offset);
    }

    TimeZoneStruct to_tz_struct(int offset) { return to_time_zone(offset); }

 
}; // namespace time_shield
 
#endif // __TIME_SHIELD_TIME_CONVERSIONS_MQH__