validation.mqh

Go to the documentation of this file.

//+------------------------------------------------------------------+
//|                                                   validation.mqh |
//|                          Time Shield - MQL5 Validation Functions |
//|                                      Copyright 2025, NewYaroslav |
//|                   https://github.com/NewYaroslav/time-shield-cpp |
//+------------------------------------------------------------------+
#ifndef __TIME_SHIELD_VALIDATION_MQH__
#define __TIME_SHIELD_VALIDATION_MQH__

 
#property copyright "Copyright 2025, NewYaroslav"
#property link      "https://github.com/NewYaroslav/time-shield-cpp"
#property strict
 
namespace time_shield {


    bool is_leap_year_date(const long year) {
       return ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0));
    }

    bool check_leap_year(const long year) { return is_leap_year_date(year); }

    bool leap_year(const long year) { return is_leap_year_date(year); }
 
    //----------------------------------------------------------------------

    bool is_leap_year_ts(const long ts) {
       const long BIAS_292277022000 = 9223371890843040000LL;
       const long BIAS_2000         = 946684800LL;
 
       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 is_leap_year_date(y);
    }

    bool leap_year_ts(const long ts) { return is_leap_year_ts(ts); }

    bool check_leap_year_ts(const long ts) { return is_leap_year_ts(ts); }

    bool is_leap_year(const long ts) { return is_leap_year_ts(ts); }
 
    //----------------------------------------------------------------------

    bool is_valid_time_zone(const int hour, const int min) {
       if (hour < 0 || hour > 23) return false;
       if (min < 0 || min > 59) return false;
       return true;
    }

    bool is_valid_tz(const int hour, const int min) {
       return is_valid_time_zone(hour, min);
    }

    bool is_valid_time_zone_offset(const TimeZoneStruct &time_zone) {
       return is_valid_time_zone(time_zone.hour, time_zone.min);
    }

    bool is_valid_time_zone(const TimeZoneStruct &time_zone) {
       return is_valid_time_zone_offset(time_zone);
    }

    bool is_valid_tz(const TimeZoneStruct &time_zone) {
       return is_valid_time_zone_offset(time_zone);
    }
 
    //----------------------------------------------------------------------

    bool is_valid_time(const int hour, const int min, const int sec, const int ms = 0) {
       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;
    }

    bool is_valid_time(const TimeStruct &time) {
       return is_valid_time(time.hour, time.min, time.sec, time.ms);
    }

    bool is_valid_date(const long year, const int month, const int day) {
       if (day > 31 && year <= 31)
          return is_valid_date((long)day, month, (int)year);
       if (year > MAX_YEAR) return false;
       if (month < 1 || month > 12) return false;
       if (day < 1 || day > 31) return false;
       if (month == FEB) {
          bool leap = is_leap_year_date(year);
          if (leap && day > 29) return false;
          if (!leap && day > 28) return false;
       } else {
          switch(month) {
          case 4:
          case 6:
          case 9:
          case 11:
             if (day > 30) return false;
             break;
          default:
             break;
          }
       }
       return true;
    }

    bool is_valid_date(const DateStruct &date) {
       return is_valid_date(date.year, date.mon, date.day);
    }

    bool is_valid_date_time(
            const long year,
            const int  month,
            const int  day,
            const int  hour = 0,
            const int  min  = 0,
            const int  sec  = 0,
            const int  ms   = 0) {
       if (!is_valid_date(year, month, day)) return false;
       if (!is_valid_time(hour, min, sec, ms)) return false;
       return true;
    }

    bool is_valid_date_time(const DateTimeStruct &date_time) {
       if (!is_valid_date(date_time)) return false;
       if (!is_valid_time(date_time)) return false;
       return true;
    }
 
    //----------------------------------------------------------------------

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

    bool is_weekend(const long ts) { return is_day_off(ts); }

    bool is_day_off_unix_day(const long unix_day) {
       int wd = (int)((unix_day + THU) % DAYS_PER_WEEK);
       return (wd == SUN || wd == SAT);
    }

    bool is_weekend_unix_day(const long unix_day) {
       return is_day_off_unix_day(unix_day);
    }

 
}; // namespace time_shield
 
#endif // __TIME_SHIELD_VALIDATION_MQH__