TimeTools.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 3/4/21.
//
 
#ifndef PICOSCENES_PLATFORM_TIMETOOLS_HXX
#define PICOSCENES_PLATFORM_TIMETOOLS_HXX
 
#include <iomanip>
#include <chrono>
#include <thread>
#include "BoostHeaders.hxx"
 
#define DATEFORMAT "%Y-%m-%d %T"
 
using namespace std::chrono_literals;
 
typedef std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> TimePoint_System_Millisecond;
 
typedef std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> TimePoint_System_Microsecond;
 
typedef std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> TimePoint_System_Second;
 
std::ostream &operator<<(std::ostream &os, const std::chrono::system_clock::time_point &t);
 
std::ostream &operator<<(std::ostream &os, const timespec &ts);
 
#if !(defined (_WIN32) || defined(WIN32))
std::ostream &operator<<(std::ostream &os, const timeval &tv);
#endif
 
namespace SystemTools::Time {
 
    template<typename TimeUnit = std::chrono::seconds>
    std::chrono::duration<TimeUnit> time_t2Duration(const time_t time) {
        return std::chrono::time_point_cast<TimeUnit>(std::chrono::seconds(time));
    }
 
    template<typename TimeUnit>
    time_t duration2Time_t(const std::chrono::duration<TimeUnit> &duration) {
        auto sec_dur = std::chrono::duration_cast<std::chrono::seconds>(duration);
        return sec_dur.count();
    }
 
    template<typename TimeUnit = std::chrono::nanoseconds, typename Rep = typename TimeUnit::rep, typename Period = typename TimeUnit::period>
    std::chrono::duration<Rep, Period> timespec2Duration(const timespec &ts) {
        auto duration = std::chrono::seconds{ts.tv_sec} + std::chrono::nanoseconds{ts.tv_nsec};
        return std::chrono::duration_cast<TimeUnit>(duration);
    }
 
    template<typename Rep, typename Period>
    struct timespec duration2Timespec(const std::chrono::duration<Rep, Period> &dur) {
        auto sec_dur = std::chrono::duration_cast<std::chrono::seconds>(dur);
        auto remain_dur = dur - sec_dur;
        auto remain_nano_dur = std::chrono::duration_cast<std::chrono::nanoseconds>(remain_dur);
        return timespec{
                .tv_sec = sec_dur.count(),
                .tv_nsec = static_cast<long>(remain_nano_dur.count()),
        };
    }
 
#if !(defined (_WIN32) || defined(WIN32))
    template<typename TimeUnit = std::chrono::microseconds>
    std::chrono::duration<TimeUnit> timeval2Duration(const timeval &tv) {
        auto duration = std::chrono::seconds{tv.tv_sec} + std::chrono::microseconds{tv.tv_usec};
        return std::chrono::duration_cast<TimeUnit>(duration);
    }
 
    template<typename TimeUnit>
    struct timeval duration2Timeval(const std::chrono::duration<TimeUnit> &dur) {
        auto sec_dur = std::chrono::duration_cast<std::chrono::seconds>(dur);
        auto remain_dur = dur - sec_dur;
        auto remain_micro_dur = std::chrono::duration_cast<std::chrono::microseconds>(remain_dur);
        return timeval{
                .tv_sec = sec_dur.count(),
                .tv_usec = remain_micro_dur.count(),
        };
    }
#endif
 
    template<typename Duration = std::chrono::seconds>
    std::chrono::time_point<std::chrono::system_clock, Duration> time_t2TimePoint(const time_t time) {
        return std::chrono::time_point_cast<Duration>(std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>(std::chrono::seconds(time)));
    }
 
    template<typename Duration>
    time_t time_point2Time_t(const std::chrono::time_point<std::chrono::system_clock, Duration> &tp) {
        auto sec_tp = std::chrono::time_point_cast<std::chrono::seconds, std::chrono::system_clock, Duration>(tp);
        return sec_tp.time_since_epoch().count();
    }
 
    template<typename Duration = std::chrono::nanoseconds>
    std::chrono::time_point<std::chrono::system_clock, Duration> timespec2TimePoint(const timespec &ts) {
        return std::chrono::time_point<std::chrono::system_clock, Duration>(std::chrono::duration_cast<Duration>(timespec2Duration<Duration>(ts)));
    }
 
#if !(defined (_WIN32) || defined(WIN32))
    template<typename Duration = std::chrono::microseconds>
    std::chrono::time_point<std::chrono::system_clock, Duration> timeval2TimePoint(const timeval &tv) {
        return std::chrono::time_point<std::chrono::system_clock, Duration>(std::chrono::duration_cast<Duration>(timeval2Duration<Duration>(tv)));
    }
#endif
 
    template<typename Duration>
    timespec time_point2Timespec(const std::chrono::time_point<std::chrono::system_clock, Duration> &tp) {
        auto sec_tp = std::chrono::time_point_cast<std::chrono::seconds>(tp);
        auto nano_dur = std::chrono::duration_cast<std::chrono::nanoseconds>(tp - sec_tp);
        return timespec{
                .tv_sec = sec_tp.time_since_epoch().count(),
                .tv_nsec = static_cast<long>(nano_dur.count()),
        };
    }
 
#if !(defined (_WIN32) || defined(WIN32))
    template<typename Duration>
    timeval time_point2Timeval(const std::chrono::time_point<std::chrono::system_clock, Duration> &tp) {
        auto sec_tp = std::chrono::time_point_cast<std::chrono::seconds>(tp);
        auto micro_dur = std::chrono::duration_cast<std::chrono::microseconds>(tp - sec_tp);
        return timeval{
                .tv_sec = sec_tp.time_since_epoch().count(),
                .tv_usec = micro_dur.count(),
        };
    }
#endif
 
    static timespec time_t2Timespec(const time_t time) {
        return timespec{
                .tv_sec = time,
                .tv_nsec = 0,
        };
    }
 
    static time_t timespec2Time_t(const timespec &ts) {
        return ts.tv_sec;
    }
 
#if !(defined (_WIN32) || defined(WIN32))
    static timeval time_t2timeval(time_t time) {
        return timeval{
                .tv_sec = time,
                .tv_usec = 0,
        };
    }
 
    static time_t timeval2Time_t(const timeval &tv) {
        return tv.tv_sec;
    }
#endif
 
    static std::string time_t2String(const time_t time, const std::string &format = DATEFORMAT) {
        std::stringstream ss;
        ss << std::put_time(std::localtime(&time), format.c_str());
        return ss.str();
    }
 
    static std::string timespec2String(const timespec &ts, const std::string &format = DATEFORMAT) {
        std::stringstream ss;
        time_t time = timespec2Time_t(ts);
        ss << std::put_time(std::localtime(&time), format.c_str());
        return ss.str();
    }
 
#if !(defined (_WIN32) || defined(WIN32))
    static std::string timeval2String(const timeval &tv, const std::string &format = DATEFORMAT) {
        std::stringstream ss;
        time_t time = timeval2Time_t(tv);
        ss << std::put_time(std::localtime(&time), format.c_str());
        return ss.str();
    }
#endif
 
    template<typename Duration>
    std::string time_point2String(const std::chrono::time_point<std::chrono::system_clock, Duration> &tp, const std::string &format = DATEFORMAT) {
        auto sec_tp = std::chrono::time_point_cast<std::chrono::seconds>(tp);
        auto timet = std::chrono::system_clock::to_time_t(sec_tp);
        return time_t2String(timet, format);
    }
 
    template<typename TimeUnit>
    std::string duration2String(const std::chrono::duration<TimeUnit> &duration, const std::string &format = DATEFORMAT) {
        auto time_t = duration2Time_t(duration);
        return time_t2String(time_t, format);
    }
 
    static time_t string2time_t(const std::string &timeString, const std::string &timeStringFormat = DATEFORMAT) {
        // FIXME: time conv
        #if !(defined (_WIN32) || defined (WIN32))
        std::tm tm = {};
        strptime(timeString.c_str(), timeStringFormat.c_str(), &tm);
        auto time = timelocal(&tm);
        return time;
        #else
        std::tm tm = {};
 
        // HACK: no time zone support
        if (timeStringFormat.find("%Z") != std::string::npos || timeStringFormat.find("%z") != std::string::npos) {
            std::string tzformat, timestr;
            if (timeStringFormat.compare(0, 3, "%z ") == 0) {
                tzformat = timeStringFormat.substr(3);
                timestr = timeString.substr(timeString.find(' ') + 1);
            } else if (timeStringFormat.compare(timeStringFormat.size() - 3, 3, " %Z") == 0) {
                tzformat = timeStringFormat.substr(0, timeStringFormat.size() - 3);
                timestr = timeString.substr(0, timeString.find_last_of(' '));
            } else {
                throw std::runtime_error(timeStringFormat + " unsupported");
            }
 
            std::istringstream ss(timestr);
 
            // Use std::get_time to parse the string based on the format
            ss >> std::get_time(&tm, tzformat.c_str());
 
            if (ss.fail()) {
                throw std::runtime_error("Failed to parse time");
            }
 
            tm.tm_isdst = -1;
 
            // Convert std::tm to time_t (mktime assumes local time)
            return _mkgmtime(&tm);
        } else {
            std::istringstream ss(timeString);
 
            // Use std::get_time to parse the string based on the format
            ss >> std::get_time(&tm, timeStringFormat.c_str());
 
            if (ss.fail()) {
                throw std::runtime_error("Failed to parse time");
            }
 
            tm.tm_isdst = -1;
 
            // Convert std::tm to time_t (mktime assumes local time)
            return mktime(&tm);
        }
        #endif
    }
 
    static struct timespec string2Timespec(const std::string &timeString, const std::string &timeStringFormat = DATEFORMAT) {
        return time_t2Timespec(string2time_t(timeString, timeStringFormat));
    }
 
    template<typename Duration = std::chrono::seconds>
    std::chrono::time_point<std::chrono::system_clock, Duration> string2time_point(const std::string &timeString, const std::string &timeStringFormat = DATEFORMAT) {
        auto time_t = string2time_t(timeString, timeStringFormat);
        return time_t2TimePoint<Duration>(time_t);
    }
 
    template<typename TimeUnit = std::chrono::seconds>
    static std::chrono::duration<TimeUnit> string2Duration(const std::string &timeString, const std::string &timeStringFormat = DATEFORMAT) {
        auto time_t = string2time_t(timeString, timeStringFormat);
        return time_t2Duration<TimeUnit>(time_t);
    }
 
    int32_t delay_periodic(int32_t delay_us);
}
 
#endif //PICOSCENES_PLATFORM_TIMETOOLS_HXX