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 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;
    }
 
    //--------------------------------------------------------------------------

    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__