time_parser.hpp

Go to the documentation of this file.

#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>
 
namespace time_shield {
 
    template<class T = Month>
    const 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] = 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>
    const T month_of_year(const std::string& month) {
        return get_month_number(month);
    }
 
//------------------------------------------------------------------------------
 
    template<class T = Month>
    const 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] = 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>
    const bool get_month_number(const std::string& month, T& value) {
        return try_get_month_number(month, value);
    }
 
    template<class T = Month>
    const bool month_of_year(const std::string& month, T& value) {
        return try_get_month_number(month, value);
    }
 
//------------------------------------------------------------------------------
 
    const 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 const bool parse_tz(const std::string& tz_str, TimeZoneStruct &tz) {
        return parse_time_zone(tz_str, tz);
    }
 
//------------------------------------------------------------------------------
 
    const 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 const 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 const 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 const 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 const ts_t ts(const std::string& str) {
        ts_t ts = 0;
        str_to_ts(str, ts);
        return ts;
    }
 
    inline const ts_ms_t ts_ms(const std::string& str) {
        ts_ms_t ts = 0;
        str_to_ts_ms(str, ts);
        return ts;
    }
 
    inline const fts_t fts(const std::string& str) {
        fts_t ts = 0;
        str_to_fts(str, ts);
        return ts;
    }
 
 
    inline const ts_t ts(const char *str) {
        ts_t ts = 0;
        str_to_ts(str, ts);
        return ts;
    }
 
    inline const ts_ms_t ts_ms(const char *str) {
        ts_ms_t ts = 0;
        str_to_ts_ms(str, ts);
        return ts;
    }
 
    inline const fts_t fts(const char *str) {
        fts_t ts = 0;
        str_to_fts(str, ts);
        return ts;
    }
};
 
#endif // _TIME_SHIELD_TIME_PARSER_HPP_INCLUDED