DateTime.mqh

Go to the documentation of this file.

//+------------------------------------------------------------------+
//|                                                     DateTime.mqh |
//|                                Time Shield - MQL5 DateTime Type |
//|                                      Copyright 2025, NewYaroslav |
//|                   https://github.com/NewYaroslav/time-shield-cpp |
//+------------------------------------------------------------------+
#ifndef TIME_SHIELD_MQL5_HEADER_TIME_SHIELD_DATETIME_MQH_INCLUDED
#define TIME_SHIELD_MQL5_HEADER_TIME_SHIELD_DATETIME_MQH_INCLUDED

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

    class DateTime {
    public:
        DateTime(): m_utc_ms(0), m_offset(0) {}

        static DateTime from_unix_ms(const long utc_ms, const int offset = 0) {
            DateTime result(utc_ms, offset);
            return result;
        }

        static DateTime now_utc(const int offset = 0) {
            DateTime result(ts_ms(), offset);
            return result;
        }

        static bool try_from_components(
                const long year,
                const int month,
                const int day,
                const int hour,
                const int min,
                const int sec,
                const int ms,
                const int offset,
                DateTime &out) {
            if (!is_valid_date_time(year, month, day, hour, min, sec, ms))
                return false;
 
            TimeZoneStruct tz = to_time_zone_struct(offset);
            if (!is_valid_time_zone_offset(tz))
                return false;
 
            const long local_ms = to_timestamp_ms(year, month, day, hour, min, sec, ms);
            DateTime result(local_ms - offset_to_ms(offset), offset);
            out = result;
            return true;
        }

        static bool try_from_date_time_struct(
                const DateTimeStruct &local_dt,
                const int offset,
                DateTime &out) {
            if (!is_valid_date_time(local_dt))
                return false;
 
            TimeZoneStruct tz = to_time_zone_struct(offset);
            if (!is_valid_time_zone_offset(tz))
                return false;
 
            const long local_ms = dt_to_timestamp_ms(local_dt);
            DateTime result(local_ms - offset_to_ms(offset), offset);
            out = result;
            return true;
        }

        static bool try_parse_iso8601(const string str, DateTime &out) {
            DateTimeStruct dt = create_date_time_struct(0);
            TimeZoneStruct tz = create_time_zone_struct(0, 0, true);
            if (!parse_iso8601(str, dt, tz))
                return false;
 
            const int offset = time_zone_struct_to_offset(tz);
            DateTime result(dt_to_timestamp_ms(dt) - offset_to_ms(offset), offset);
            out = result;
            return true;
        }

        string to_iso8601() const { return to_iso8601_ms(local_ms(), m_offset); }

        long unix_ms() const { return m_utc_ms; }

        int utc_offset() const { return m_offset; }

        DateTime with_offset(const int new_offset) const {
            DateTime result(m_utc_ms, new_offset);
            return result;
        }

        DateTime to_utc() const { return with_offset(0); }
 
    private:
        DateTime(const long utc_ms, const int offset): m_utc_ms(utc_ms), m_offset(offset) {}
 
        static long offset_to_ms(const int offset) { return (long)offset * MS_PER_SEC; }
 
        long local_ms() const { return m_utc_ms + offset_to_ms(m_offset); }
 
        long m_utc_ms;
        int m_offset;
    };
 
} // namespace time_shield
 
#endif // TIME_SHIELD_MQL5_HEADER_TIME_SHIELD_DATETIME_MQH_INCLUDED