time_parser.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef _TIME_SHIELD_TIME_PARSER_HPP_INCLUDED
#define _TIME_SHIELD_TIME_PARSER_HPP_INCLUDED

 
#include "enums.hpp"
#include "constants.hpp"
#include "date_time_struct.hpp"
#include "time_zone_struct.hpp"
#include "validation.hpp"
#include "time_conversions.hpp"
#include <regex>
#include <algorithm>
#include <locale>
#include <array>
#include <stdexcept>
#include <sstream>
#include <cctype>
 
namespace time_shield {


    template<class T = Month>
    T get_month_number(const std::string& month) {
        if (month.empty()) throw std::invalid_argument("Invalid month name");
 
        std::string month_copy = month;
        std::transform(month_copy.begin(), month_copy.end(), month_copy.begin(), [](char &ch) {
            return std::use_facet<std::ctype<char>>(std::locale()).tolower(ch);
        });
        month_copy[0] = static_cast<char>(std::toupper(month_copy[0]));
 
        static const std::array<std::string, 12> short_names = {
            "Jan", "Feb", "Mar", "Apr", "May", "Jun",
            "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
        };
        static const std::array<std::string, 12> 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 == short_names[i] || month == full_names[i]) {
                return static_cast<T>(i + 1);
            }
        }
        throw std::invalid_argument("Invalid month name");
    }

    template<class T = Month>
    T month_of_year(const std::string& month) {
        return get_month_number(month);
    }
 
//------------------------------------------------------------------------------

    template<class T = Month>
    bool try_get_month_number(const std::string& month, T& value) {
        if (month.empty()) return false;
 
        std::string month_copy = month;
        std::transform(month_copy.begin(), month_copy.end(), month_copy.begin(), [](char &ch) {
            return std::use_facet<std::ctype<char>>(std::locale()).tolower(ch);
        });
        month_copy[0] = static_cast<char>(std::toupper(month_copy[0]));
 
        static const std::array<std::string, MONTHS_PER_YEAR> short_names = {
            "Jan", "Feb", "Mar", "Apr", "May", "Jun",
            "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
        };
        static const std::array<std::string, MONTHS_PER_YEAR> 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]) {
                value = static_cast<T>(i + 1);
                return true;
            }
        }
        return false;
    }

    template<class T = Month>
    bool get_month_number(const std::string& month, T& value) {
        return try_get_month_number(month, value);
    }

    template<class T = Month>
    bool month_of_year(const std::string& month, T& value) {
        return try_get_month_number(month, value);
    }
 
//------------------------------------------------------------------------------

    inline bool parse_time_zone(const std::string& tz_str, TimeZoneStruct &tz) {
        if (tz_str.empty()) {
            tz.hour = 0;
            tz.min = 0;
            tz.is_positive = true;
            return true;
        }
        if (tz_str == "Z") {
            tz.hour = 0;
            tz.min = 0;
            tz.is_positive = true;
            return true;
        }
        tz.is_positive = (tz_str[0] == '+');
        tz.hour = std::stoi(tz_str.substr(1, 2));
        tz.min = std::stoi(tz_str.substr(4, 2));
        return is_valid_time_zone(tz);
    }

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

    inline bool parse_iso8601(
            const std::string& input,
            DateTimeStruct &dt,
            TimeZoneStruct &tz) {
        // Регулярное выражение для даты в формате ISO8601
        static const std::regex date_regex(R"((\d{4})[-\/\.](\d{2})[-\/\.](\d{2}))");
        std::smatch date_match;
 
        // Регулярное выражение для времени в формате ISO8601 с часовым поясом и без
        static const std::regex time_regex(R"((\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})?)");
        std::smatch time_match;
 
        dt = create_date_time_struct(0);
        tz = create_time_zone_struct(0, 0);
 
        // Парсинг даты
        if (std::regex_search(input, date_match, date_regex)) {
            dt.year = std::stoll(date_match[1].str());
            dt.mon = std::stoi(date_match[2].str());
            dt.day = std::stoi(date_match[3].str());
        } else {
            return false;
        }
 
        // Парсинг времени и часового пояса
        if (std::regex_search(input, time_match, time_regex)) {
            dt.hour = std::stoi(time_match[1].str());
            dt.min = std::stoi(time_match[2].str());
            dt.sec = std::stoi(time_match[3].str());
            if (time_match[4].matched) {
                dt.ms = std::stoi(time_match[4].str());
            }
            if (time_match[5].matched) {
                if (!parse_time_zone(time_match[5].str(), tz)) return false;
            }
            return is_valid_date_time(dt);
        }
        return true;
    }

    inline bool str_to_ts(const std::string &str, ts_t& ts) {
        DateTimeStruct dt;
        TimeZoneStruct tz;
        if (!parse_iso8601(str, dt, tz)) return false;
        try {
            ts = to_timestamp(dt) + to_offset(tz);
            return true;
        } catch(...) {}
        return false;
    }

    inline bool str_to_ts_ms(const std::string &str, ts_ms_t& ts) {
        DateTimeStruct dt;
        TimeZoneStruct tz;
        if (!parse_iso8601(str, dt, tz)) return false;
        try {
            ts = to_timestamp_ms(dt) + sec_to_ms(to_offset(tz));
            return true;
        } catch(...) {}
        return false;
    }

    inline bool is_workday(const std::string& str) {
        ts_t ts = 0;
        if (!str_to_ts(str, ts)) {
            return false;
        }
        return is_workday(ts);
    }

    inline bool is_workday_ms(const std::string& str) {
        ts_ms_t ts = 0;
        if (!str_to_ts_ms(str, ts)) {
            return false;
        }
        return is_workday_ms(ts);
    }

    inline bool workday(const std::string& str) {
        return is_workday(str);
    }

    inline bool workday_ms(const std::string& str) {
        return is_workday_ms(str);
    }

    inline bool is_first_workday_of_month(const std::string& str) {
        ts_t ts = 0;
        if (!str_to_ts(str, ts)) {
            return false;
        }
        return is_first_workday_of_month(ts);
    }

    inline bool is_first_workday_of_month_ms(const std::string& str) {
        ts_ms_t ts = 0;
        if (!str_to_ts_ms(str, ts)) {
            return false;
        }
        return is_first_workday_of_month_ms(ts);
    }

    inline bool is_within_first_workdays_of_month(const std::string& str, int count) {
        ts_t ts = 0;
        if (!str_to_ts(str, ts)) {
            return false;
        }
        return is_within_first_workdays_of_month(ts, count);
    }

    inline bool is_within_first_workdays_of_month_ms(const std::string& str, int count) {
        ts_ms_t ts = 0;
        if (!str_to_ts_ms(str, ts)) {
            return false;
        }
        return is_within_first_workdays_of_month_ms(ts, count);
    }

    inline bool is_last_workday_of_month(const std::string& str) {
        ts_t ts = 0;
        if (!str_to_ts(str, ts)) {
            return false;
        }
        return is_last_workday_of_month(ts);
    }

    inline bool is_last_workday_of_month_ms(const std::string& str) {
        ts_ms_t ts = 0;
        if (!str_to_ts_ms(str, ts)) {
            return false;
        }
        return is_last_workday_of_month_ms(ts);
    }

    inline bool is_within_last_workdays_of_month(const std::string& str, int count) {
        ts_t ts = 0;
        if (!str_to_ts(str, ts)) {
            return false;
        }
        return is_within_last_workdays_of_month(ts, count);
    }

    inline bool is_within_last_workdays_of_month_ms(const std::string& str, int count) {
        ts_ms_t ts = 0;
        if (!str_to_ts_ms(str, ts)) {
            return false;
        }
        return is_within_last_workdays_of_month_ms(ts, count);
    }

    inline bool str_to_fts(const std::string &str, fts_t& ts) {
        DateTimeStruct dt;
        TimeZoneStruct tz;
        if (!parse_iso8601(str, dt, tz)) return false;
        try {
            ts = to_ftimestamp(dt) + static_cast<fts_t>(to_offset(tz));
            return true;
        } catch(...) {}
        return false;
    }

    inline ts_t ts(const std::string& str) {
        ts_t ts = 0;
        str_to_ts(str, ts);
        return ts;
    }

    inline ts_ms_t ts_ms(const std::string& str) {
        ts_ms_t ts = 0;
        str_to_ts_ms(str, ts);
        return ts;
    }

    inline fts_t fts(const std::string& str) {
        fts_t ts = 0;
        str_to_fts(str, ts);
        return ts;
    }
 
    //--------------------------------------------------------------------------

    template<class T = int>
    inline bool sec_of_day(const std::string& str, T& sec) {
        if (str.empty()) return false;
 
        const char* p = str.c_str();
        int parts[3] = {0, 0, 0}; // hour, minute, second
        int idx = 0;
 
        while (*p && idx < 3) {
            // Parse integer
            int value = 0;
            bool has_digit = false;
 
            while (*p >= '0' && *p <= '9') {
                has_digit = true;
                value = value * 10 + (*p - '0');
                ++p;
            }
 
            if (!has_digit) return false;
            parts[idx++] = value;
 
            // Expect colon or end
            if (*p == ':') {
                ++p;
            } else if (*p == '\0') {
                break;
            } else {
                return false; // unexpected character
            }
        }
 
        if (idx == 0) return false;
        if (!is_valid_time(parts[0], parts[1], parts[2])) return false;
 
        sec = static_cast<T>(sec_of_day(parts[0], parts[1], parts[2]));
        return true;
    }

    template<class T = int>
    inline T sec_of_day(const std::string& str) {
        T value{};
        if (sec_of_day(str, value))
            return value;
        return static_cast<T>(SEC_PER_DAY);
    }
 

    inline ts_t ts(const char *str) {
        ts_t ts = 0;
        str_to_ts(str, ts);
        return ts;
    }

    inline ts_ms_t ts_ms(const char *str) {
        ts_ms_t ts = 0;
        str_to_ts_ms(str, ts);
        return ts;
    }

    inline fts_t fts(const char *str) {
        fts_t ts = 0;
        str_to_fts(str, ts);
        return ts;
    }

 
};
 
#endif // _TIME_SHIELD_TIME_PARSER_HPP_INCLUDED