time_parser.mqh

Go to the documentation of this file.

//+------------------------------------------------------------------+
//|                                                  time_parser.mqh |
//|                                   Time Shield - MQL5 Time Parser |
//|                                      Copyright 2025, NewYaroslav |
//|                   https://github.com/NewYaroslav/time-shield-cpp |
//+------------------------------------------------------------------+
#ifndef __TIME_SHIELD_TIME_PARSER_MQH__
#define __TIME_SHIELD_TIME_PARSER_MQH__

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


    int get_month_number(string month) {
       if(StringLen(month)==0)
          return 0;
       string month_copy = month;
       string tmp = "";
       StringConcatenate(tmp,
                        StringToUpper(StringSubstr(month_copy,0,1)),
                        StringToLower(StringSubstr(month_copy,1)));
       month_copy = tmp;
       static const string short_names[] = {"Jan","Feb","Mar","Apr","May","Jun",
                                            "Jul","Aug","Sep","Oct","Nov","Dec"};
       static const string full_names[]  = {"January","February","March","April","May","June",
                                            "July","August","September","October","November","December"};
       for(int i=0;i<MONTHS_PER_YEAR;++i)
       {
          if(month_copy==short_names[i] || month_copy==full_names[i])
             return i+1;
       }
       return 0;
    }

    int month_of_year(string month) { return get_month_number(month); }
 
//------------------------------------------------------------------------------

    bool try_get_month_number(string month, int &value) {
       int res = get_month_number(month);
       if(res==0)
          return false;
       value = res;
       return true;
    }

    bool get_month_number(string month, int &value) { return try_get_month_number(month,value); }

    bool month_of_year(string month, int &value) { return try_get_month_number(month,value); }
 
//------------------------------------------------------------------------------
 
    bool timeframe_is_ascii_space(const int ch) {
       return ch==' ' || ch=='\t' || ch=='\n' || ch=='\r' || ch=='\f' || ch=='\v';
    }
 
    bool timeframe_is_ascii_digit(const int ch) {
       return ch>='0' && ch<='9';
    }
 
    bool timeframe_is_ascii_alpha(const int ch) {
       return (ch>='A' && ch<='Z') || (ch>='a' && ch<='z');
    }
 
    int timeframe_ascii_to_lower(const int ch) {
       if(ch>='A' && ch<='Z')
          return ch - 'A' + 'a';
       return ch;
    }
 
    string timeframe_trim_ascii(string value) {
       int begin = 0;
       int end = StringLen(value);
       while(begin < end && timeframe_is_ascii_space(StringGetCharacter(value, begin)))
          ++begin;
       while(end > begin && timeframe_is_ascii_space(StringGetCharacter(value, end - 1)))
          --end;
       return StringSubstr(value, begin, end - begin);
    }
 
    bool timeframe_ascii_iequals(string value, string literal) {
       const int len = StringLen(value);
       if(len != StringLen(literal))
          return false;
 
       for(int i = 0; i < len; ++i) {
          if(timeframe_ascii_to_lower(StringGetCharacter(value, i))
             != timeframe_ascii_to_lower(StringGetCharacter(literal, i)))
             return false;
       }
 
       return true;
    }
 
    bool timeframe_try_parse_positive_long(string value, long &out) {
       const string trimmed = timeframe_trim_ascii(value);
       const int len = StringLen(trimmed);
       const string k_max_long = "9223372036854775807";
       out = 0;
       if(len <= 0)
          return false;
 
       for(int i = 0; i < len; ++i) {
          if(!timeframe_is_ascii_digit(StringGetCharacter(trimmed, i)))
             return false;
       }
 
       if(len > StringLen(k_max_long))
          return false;
       if(len == StringLen(k_max_long) && StringCompare(trimmed, k_max_long) > 0)
          return false;
 
       for(int i = 0; i < len; ++i)
          out = out * 10 + (long)(StringGetCharacter(trimmed, i) - '0');
 
       return out > 0;
    }
 
    bool timeframe_try_multiply_positive_long(long lhs, long rhs, long &out) {
       const long k_max_long = 9223372036854775807;
       out = 0;
       if(lhs <= 0 || rhs <= 0)
          return false;
       if(lhs > k_max_long / rhs)
          return false;
       out = lhs * rhs;
       return true;
    }
 
    bool timeframe_try_get_unit_seconds_compact(string unit, long &unit_seconds) {
       const string normalized = StringToLower(unit);
       unit_seconds = 0;
       if(normalized == "s") { unit_seconds = 1; return true; }
       if(normalized == "m") { unit_seconds = SEC_PER_MIN; return true; }
       if(normalized == "h") { unit_seconds = SEC_PER_HOUR; return true; }
       if(normalized == "d") { unit_seconds = SEC_PER_DAY; return true; }
       if(normalized == "w") { unit_seconds = 7 * SEC_PER_DAY; return true; }
       if(normalized == "mn") { unit_seconds = 30 * SEC_PER_DAY; return true; }
       if(normalized == "q") { unit_seconds = 90 * SEC_PER_DAY; return true; }
       if(normalized == "y") { unit_seconds = SEC_PER_YEAR; return true; }
       return false;
    }
 
    bool timeframe_try_get_unit_seconds_word(string unit, long &unit_seconds) {
       const string normalized = StringToLower(unit);
       unit_seconds = 0;
       if(normalized == "sec" || normalized == "second" || normalized == "seconds") { unit_seconds = 1; return true; }
       if(normalized == "min" || normalized == "minute" || normalized == "minutes") { unit_seconds = SEC_PER_MIN; return true; }
       if(normalized == "hr" || normalized == "hour" || normalized == "hours") { unit_seconds = SEC_PER_HOUR; return true; }
       if(normalized == "day" || normalized == "days") { unit_seconds = SEC_PER_DAY; return true; }
       if(normalized == "week" || normalized == "weeks") { unit_seconds = 7 * SEC_PER_DAY; return true; }
       if(normalized == "month" || normalized == "months") { unit_seconds = 30 * SEC_PER_DAY; return true; }
       if(normalized == "quarter" || normalized == "quarters") { unit_seconds = 90 * SEC_PER_DAY; return true; }
       if(normalized == "year" || normalized == "years") { unit_seconds = SEC_PER_YEAR; return true; }
       return false;
    }
 
    bool timeframe_try_parse_seconds(string str, long &seconds) {
       str = timeframe_trim_ascii(str);
       seconds = 0;
       const int len = StringLen(str);
       if(len <= 0)
          return false;
 
       long multiplier = 1;
       long unit_seconds = 0;
       long result = 0;
       const int first = StringGetCharacter(str, 0);
 
       if(timeframe_is_ascii_digit(first)) {
          int pos = 0;
          while(pos < len && timeframe_is_ascii_digit(StringGetCharacter(str, pos)))
             ++pos;
 
          if(!timeframe_try_parse_positive_long(StringSubstr(str, 0, pos), multiplier))
             return false;
 
          while(pos < len && timeframe_is_ascii_space(StringGetCharacter(str, pos)))
             ++pos;
          if(pos >= len)
             return false;
 
          string unit = StringSubstr(str, pos);
          for(int i = 0; i < StringLen(unit); ++i) {
             if(!timeframe_is_ascii_alpha(StringGetCharacter(unit, i)))
                return false;
          }
 
          if(!timeframe_try_get_unit_seconds_word(unit, unit_seconds))
             return false;
          if(!timeframe_try_multiply_positive_long(multiplier, unit_seconds, result))
             return false;
 
          seconds = result;
          return true;
       }
 
       if(!timeframe_is_ascii_alpha(first))
          return false;
 
       int pos = 0;
       while(pos < len && timeframe_is_ascii_alpha(StringGetCharacter(str, pos)))
          ++pos;
 
       string unit = StringSubstr(str, 0, pos);
       if(pos == len) {
          if(!timeframe_try_get_unit_seconds_word(unit, unit_seconds))
             return false;
          seconds = unit_seconds;
          return true;
       }
 
       if(timeframe_is_ascii_space(StringGetCharacter(str, pos)))
          return false;
 
       for(int i = pos; i < len; ++i) {
          if(!timeframe_is_ascii_digit(StringGetCharacter(str, i)))
             return false;
       }
 
       if(!timeframe_try_get_unit_seconds_compact(unit, unit_seconds))
          return false;
       if(!timeframe_try_parse_positive_long(StringSubstr(str, pos), multiplier))
          return false;
       if(!timeframe_try_multiply_positive_long(multiplier, unit_seconds, result))
          return false;
 
       seconds = result;
       return true;
    }

    bool parse_time_zone(string tz_str, TimeZoneStruct &tz)
    {
       if(StringLen(tz_str)==0 || tz_str=="Z")
       {
          tz.hour=0; tz.min=0; tz.is_positive=true; return true;
       }
       tz.is_positive = ((char)tz_str[0] =='+');
       tz.hour = (int)StringToInteger(StringSubstr(tz_str,1,2));
       tz.min  = (int)StringToInteger(StringSubstr(tz_str,4,2));
       return is_valid_time_zone(tz);
    }

    bool parse_tz(string tz_str, TimeZoneStruct &tz) { return parse_time_zone(tz_str, tz); }
 
//------------------------------------------------------------------------------

    bool parse_iso8601(string input_str, DateTimeStruct &dt, TimeZoneStruct &tz) {
       dt = create_date_time_struct(0);
       tz = create_time_zone_struct(0,0);
 
       string date_part=input_str;
       string time_part="";
       int posT=StringFind(input_str,"T");
       if (posT<0) posT=StringFind(input_str," ");
       if (posT>=0) {
          date_part=StringSubstr(input_str,0,posT);
          time_part=StringSubstr(input_str,posT+1);
       }
 
       string parts[];
       int cnt = StringSplit(date_part,'-',parts);
       if (cnt<3) {
          cnt = StringSplit(date_part,'/',parts);
          if (cnt<3) cnt = StringSplit(date_part,'.',parts);
       }
       if (cnt<3) return false;
       dt.year=(long)StringToInteger(parts[0]);
       dt.mon =(int)StringToInteger(parts[1]);
       dt.day =(int)StringToInteger(parts[2]);
 
       if(!is_valid_date(dt))
          return false;
 
       if (StringLen(time_part)>0) {
          string tz_str = "";
          int zpos = StringFind(time_part,"Z");
          int ppos = StringFind(time_part,"+");
          int npos = StringFind(time_part,"-");
          int tzpos = -1;
          if (zpos >= 0){ tzpos=zpos; tz_str=StringSubstr(time_part,zpos); }
          else if(ppos >= 0){ tzpos=ppos; tz_str=StringSubstr(time_part,ppos); }
          else if(npos > 0){ tzpos=npos; tz_str=StringSubstr(time_part,npos); }
          if (tzpos >= 0) time_part=StringSubstr(time_part,0,tzpos);
 
          string tparts[];
          int tcnt=StringSplit(time_part,':',tparts);
          if (tcnt < 2)
             return is_valid_date_time(dt);
          dt.hour = (int)StringToInteger(tparts[0]);
          dt.min  = (int)StringToInteger(tparts[1]);
          if (tcnt >= 3) {
             string sec_part=tparts[2];
             int dot = StringFind(sec_part, ".");
             if (dot >= 0) {
                dt.sec = (int)StringToInteger(StringSubstr(sec_part,0,dot));
                dt.ms  = (int)StringToInteger(StringSubstr(sec_part,dot+1));
             } else {
                dt.sec = (int)StringToInteger(sec_part);
             }
          }
          if (StringLen(tz_str)>0) {
             if (!parse_time_zone(tz_str,tz)) return false;
          }
       }
       return is_valid_date_time(dt);
    }

    bool str_to_ts(string str, long &ts) {
       DateTimeStruct dt; TimeZoneStruct tz;
       if(!parse_iso8601(str, dt, tz)) return false;
       ts = to_timestamp(dt) + to_offset(tz);
       return true;
    }

    bool str_to_ts_ms(string str, long &ts) {
       DateTimeStruct dt; TimeZoneStruct tz;
       if(!parse_iso8601(str, dt, tz)) return false;
       ts = to_timestamp_ms(dt) + sec_to_ms(to_offset(tz));
       return true;
    }

    bool is_workday(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return false;
       return is_workday(ts);
    }

    bool workday(string str) { return is_workday(str); }

    bool is_workday_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return false;
       return is_workday_ms(ts);
    }

    bool workday_ms(string str) { return is_workday_ms(str); }

    bool is_first_workday_of_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return false;
       return is_first_workday_of_month(ts);
    }

    bool is_first_workday_of_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return false;
       return is_first_workday_of_month_ms(ts);
    }

    bool is_within_first_workdays_of_month(string str, int count) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return false;
       return is_within_first_workdays_of_month(ts, count);
    }

    bool is_within_first_workdays_of_month_ms(string str, int count) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return false;
       return is_within_first_workdays_of_month_ms(ts, count);
    }

    bool is_last_workday_of_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return false;
       return is_last_workday_of_month(ts);
    }

    bool is_last_workday_of_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return false;
       return is_last_workday_of_month_ms(ts);
    }

    bool is_within_last_workdays_of_month(string str, int count) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return false;
       return is_within_last_workdays_of_month(ts, count);
    }

    bool is_within_last_workdays_of_month_ms(string str, int count) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return false;
       return is_within_last_workdays_of_month_ms(ts, count);
    }

    long start_of_first_workday_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return ERROR_TIMESTAMP;
       return start_of_first_workday_month(ts);
    }

    long start_of_first_workday_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return ERROR_TIMESTAMP;
       return start_of_first_workday_month_ms(ts);
    }

    long end_of_first_workday_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return ERROR_TIMESTAMP;
       return end_of_first_workday_month(ts);
    }

    long end_of_first_workday_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return ERROR_TIMESTAMP;
       return end_of_first_workday_month_ms(ts);
    }

    long start_of_last_workday_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return ERROR_TIMESTAMP;
       return start_of_last_workday_month(ts);
    }

    long start_of_last_workday_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return ERROR_TIMESTAMP;
       return start_of_last_workday_month_ms(ts);
    }

    long end_of_last_workday_month(string str) {
       long ts = 0;
       if(!str_to_ts(str, ts))
          return ERROR_TIMESTAMP;
       return end_of_last_workday_month(ts);
    }

    long end_of_last_workday_month_ms(string str) {
       long ts = 0;
       if(!str_to_ts_ms(str, ts))
          return ERROR_TIMESTAMP;
       return end_of_last_workday_month_ms(ts);
    }

    bool str_to_fts(string str, double &ts) {
       DateTimeStruct dt; TimeZoneStruct tz;
       if(!parse_iso8601(str, dt, tz)) return false;
       ts = to_ftimestamp(dt) + (double)to_offset(tz);
       return true;
    }

    long ts(string str) {
       long v=0;
       str_to_ts(str,v);
       return v;
    }

    long ts_ms(string str) {
       long v=0;
       str_to_ts_ms(str,v);
       return v;
    }

    double fts(string str) {
        double v=0.0;
        str_to_fts(str,v);
        return v;
    }
 
    //--------------------------------------------------------------------------

    bool str_to_timeframe_sec(string str, long &seconds) {
       return timeframe_try_parse_seconds(str, seconds);
    }

    bool str_to_timeframe_ms(string str, long &milliseconds) {
       long seconds = 0;
       if(!timeframe_try_parse_seconds(str, seconds)) {
          milliseconds = 0;
          return false;
       }
 
       if(!timeframe_try_multiply_positive_long(seconds, MS_PER_SEC, milliseconds)) {
          milliseconds = 0;
          return false;
       }
 
       return true;
    }

    long timeframe_sec(string str) {
       long value = 0;
       str_to_timeframe_sec(str, value);
       return value;
    }

    long timeframe_ms(string str) {
       long value = 0;
       str_to_timeframe_ms(str, value);
       return value;
    }
 
    //--------------------------------------------------------------------------

    int sec_of_day(string str) {
        string result[];
        const int k = StringSplit(str, ':', result);
 
        if (k < 1 || k > 3)
            return (int)SEC_PER_DAY;
 
        int h = 0, m = 0, s = 0;
 
        h = (int)StringToInteger(result[0]);
        if (k > 1) m = (int)StringToInteger(result[1]);
        if (k > 2) s = (int)StringToInteger(result[2]);
 
        if (!is_valid_time(h, m, s)) return (int)SEC_PER_DAY;
 
        return sec_of_day(h, m, s);
    }

 
}; // namespace time_shield
 
#endif // __TIME_SHIELD_TIME_PARSER_MQH__