MuditaOS/module-utils/time/time_conversion.cpp

#include <algorithm>
#include <array>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <time.h>
#include <iomanip>
#include <locale>
#include <i18/i18.hpp>

#include "time_conversion.hpp"
#include "time_locale.hpp"

namespace utils {
namespace time {

Locale tlocale;

UTF8 Localer::get_replacement(Replacements val, const struct tm &timeinfo)
{
    UTF8 retval = "";
    switch (val) {
    case DayLong:
        retval = Locale::get_day(Locale::Day(timeinfo.tm_wday - 1));
        break;
    case DayAbbrev:
        retval = Locale::get_day(Locale::Day(timeinfo.tm_wday - 1)).substr(0,abbrev_len);
        break;
    case MonthLong:
        retval = Locale::get_month(Locale::Month(timeinfo.tm_mon));
        break;
    case MonthAbbrev:
        retval = Locale::get_month(Locale::Month(timeinfo.tm_mon)).substr(0,abbrev_len);
        break;
    case Timezone:
        break;
    }
    return retval;
}

void Timestamp::replace_specifiers()
{
        int replacements_n = 0;
        const int strtof_formatter_size = 2;
        for (auto &el : specifiers_replacement) {
            auto begin_pos = format.begin();
            auto found_pos = format.begin();
            while (found_pos != format.end()) {
                begin_pos = format.begin();
                found_pos = std::search(begin_pos, format.end(), el.begin(), el.end());
                if (found_pos != format.end()) {
                    UTF8 begin = std::string(begin_pos, found_pos);
                    UTF8 day = get_replacement(Replacements(replacements_n), timeinfo);
                    UTF8 next;
                    // std::next doesnt care for distance... (doesn't return element.end()) need to check it
                    if (std::distance(found_pos, format.end()) <= strtof_formatter_size) {
                        next = "";
                    } else {
                        next = std::string(std::next(found_pos, strtof_formatter_size), format.end());
                    }
                    format = (begin + day + next).c_str();
                }
            }
            ++replacements_n;
        }
    }

    void Timestamp::set_time(time_t newtime)
    {
        time = newtime;
        timeinfo = *localtime(&time);
    }

    void Timestamp::set_time(std::string timestr, const char *format)
    {

        std::stringstream stream(timestr);
        try
		{
            stream >> std::get_time(&(this->timeinfo), "%y/%m/%d %H:%M:%S");

            // add missing years, otherwise mktime returns bad timestamp
            timeinfo.tm_year += 100;
            this->time = mktime(&timeinfo);
        }
		catch (std::exception &e)
		{
			LOG_ERROR("Time::set_time error %s", e.what());
		}
    }
    UTF8 Timestamp::str(std::string format)
    {
        if(format.compare("") !=0) this->format = format;
        UTF8 datetimestr = "";
        replace_specifiers();
        std::strftime((char *)data, datasize, this->format.c_str(), &timeinfo);
        datetimestr = data;
        return datetimestr;
    }

    UTF8 Timestamp::day(bool abbrev)
    {
        if(abbrev) {
            return get_replacement(Replacements::DayAbbrev, timeinfo);
        } else {
            return get_replacement(Replacements::DayLong, timeinfo);
        }
    }

    UTF8 Timestamp::month(bool abbrev)
    {
        if(abbrev) {
            return get_replacement(Replacements::MonthAbbrev, timeinfo);
        } else {
            return get_replacement(Replacements::MonthLong, timeinfo);
        }
    }

    void DateTime::before_n_sec(time_t val)
    {
        local_time = time;
        if (val)
        {
            set_time(val);
        }
    }

    bool DateTime::isToday()
    {
        auto newer_timeinfo = *localtime(&local_time);
        return (newer_timeinfo.tm_yday == timeinfo.tm_yday && newer_timeinfo.tm_year == timeinfo.tm_year);
    }

    bool DateTime::isYesterday()
    {
        auto newer_timeinfo = *localtime(&local_time);
        bool is_leap_year = (timeinfo.tm_year % 4 == 0 && timeinfo.tm_year % 100 != 0) || timeinfo.tm_year % 400 == 0;

        return (((newer_timeinfo.tm_yday - timeinfo.tm_yday == 1) && (newer_timeinfo.tm_year == timeinfo.tm_year)) // day difference
                || (timeinfo.tm_year == 0 && newer_timeinfo.tm_year + 364 + is_leap_year)                          // day next year day difference
        );
    }

    UTF8 DateTime::str(std::string format)
    {
        if (format.compare("") != 0)
        {
            return Timestamp::str(format);
        }
        if (isToday()) // if the same computer day, then return hour.
        {
            return Timestamp::str(Locale::format(Locale::FormatTime12H));
        }
        else if (show_textual_past && isYesterday())
        {
            return Locale::yesterday();
        }
        else
        {
            return Timestamp::str(Locale::format(date_format_long ? Locale::FormatLocaleDateFull : Locale::FormatLocaleDateShort));
        }
    }
    UTF8 Timestamp::get_date_time_substr(GetParameters param)
    {
        auto value = get_date_time_sub_value(param);
        if (value != UINT32_MAX)
        {
            return UTF8(std::to_string(value));
        }
        return UTF8();
    }

    uint32_t Timestamp::get_date_time_sub_value(GetParameters param)
    {
        switch (param)
        {
        case GetParameters::Hour:
            return timeinfo.tm_hour;
            break;
        case GetParameters::Minute:
            return timeinfo.tm_min;
            break;
        case GetParameters::Day:
            return timeinfo.tm_mday;
            break;
        case GetParameters::Month:
            return timeinfo.tm_mon + 1;
            break;
        case GetParameters::Year:
            return timeinfo.tm_year + 1900;
            break;
        }
        return UINT32_MAX;
    }
    UTF8 Date::str(std::string format)
    {
        if (!format.empty())
        {
            return Timestamp::str(format);
        }
        else if (show_textual_past)
        {
            if (isToday())
            {
                return Locale::today();
            }
            else if (isYesterday())
            {
                return Locale::yesterday();
            }
        }

        return Timestamp::str(Locale::format(date_format_long ? Locale::FormatLocaleDateFull : Locale::FormatLocaleDateShort));
    }

    UTF8 Time::str(std::string format)
    {
        if (!format.empty())
        {
            return Timestamp::str(format);
        }
        else
        {
            return Timestamp::str(Locale::format(Locale::FormatTime12H)); // @TODO: M.G. FormatLocaleTime which actually works
        }
    }

}; // namespace time
}; // utils