timeParsing.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TIME_HPP
#define RTCTK_COMPONENTFRAMEWORK_TIME_HPP
 
#include <array>
#include <chrono>
#include <format>
#include <optional>
#include <spanstream>
#include <string>
 
namespace rtctk::componentFramework {

// TODO: switch to string_view once https://cplusplus.github.io/LWG/lwg-defects.html#3554 (in C++23)
//       support lands in gcc
static constexpr std::array<std::string, 5> TIMEPOINT_FORMATS = {
    "%FT%TZ",
    "%FT%T%Ez",
    "%FT%T %Z",
    "%FT%T",
    "%FT%R",
};
template <class Tp>
bool ParseTimepoint(const std::string_view time, Tp& timepoint) {
    // Check if time string contains 'T'
    if (time.find('T') != std::string::npos) {
        for (const auto& format : TIMEPOINT_FORMATS) {
            std::ispanstream time_spanstream(time);
            time_spanstream >> std::chrono::parse(format, timepoint);
            if (time_spanstream) {
                return true;
            }
        }
    }
    // Check if time string contains ':'
    else if (time.find(':') != std::string::npos) {
        auto time_prefixed = std::format("{:%Y-%m-%d}T{}", Tp::clock::now(), time);
        for (const auto& format : TIMEPOINT_FORMATS) {
            std::ispanstream time_spanstream(time_prefixed);
            time_spanstream >> std::chrono::parse(format, timepoint);
            if (time_spanstream) {
                return true;
            }
        }
    }
    // Try just %F format
    else {
        std::ispanstream time_spanstream(time);
        time_spanstream >> std::chrono::parse("%F", timepoint);
        return static_cast<bool>(time_spanstream);
    }
 
    return false;
}

std::optional<std::chrono::nanoseconds> ParseDuration(const std::string_view duration) {
    static constexpr std::array<std::pair<std::string_view, std::chrono::nanoseconds>, 39>
        unit_map = {{// Time units (abbreviations)
                     {"h", std::chrono::hours{1}},
                     {"hr", std::chrono::hours{1}},
                     {"hour", std::chrono::hours{1}},
                     {"hours", std::chrono::hours{1}},
                     {"d", std::chrono::days{1}},
                     {"day", std::chrono::days{1}},
                     {"days", std::chrono::days{1}},
                     {"w", std::chrono::weeks{1}},
                     {"wk", std::chrono::weeks{1}},
                     {"week", std::chrono::weeks{1}},
                     {"weeks", std::chrono::weeks{1}},
                     {"y", std::chrono::years{1}},
                     {"yr", std::chrono::years{1}},
                     {"year", std::chrono::years{1}},
                     {"years", std::chrono::years{1}},
                     {"ms", std::chrono::milliseconds{1}},
                     {"milli", std::chrono::milliseconds{1}},
                     {"millis", std::chrono::milliseconds{1}},
                     {"millisecond", std::chrono::milliseconds{1}},
                     {"milliseconds", std::chrono::milliseconds{1}},
                     {"us", std::chrono::microseconds{1}},
                     {"micro", std::chrono::microseconds{1}},
                     {"micros", std::chrono::microseconds{1}},
                     {"microsecond", std::chrono::microseconds{1}},
                     {"microseconds", std::chrono::microseconds{1}},
                     {"µs", std::chrono::microseconds{1}},
                     {"ns", std::chrono::nanoseconds{1}},
                     {"nano", std::chrono::nanoseconds{1}},
                     {"nanos", std::chrono::nanoseconds{1}},
                     {"nanosecond", std::chrono::nanoseconds{1}},
                     {"nanoseconds", std::chrono::nanoseconds{1}},
                     {"s", std::chrono::seconds{1}},
                     {"sec", std::chrono::seconds{1}},
                     {"second", std::chrono::seconds{1}},
                     {"seconds", std::chrono::seconds{1}},
                     {"m", std::chrono::minutes{1}},
                     {"min", std::chrono::minutes{1}},
                     {"minute", std::chrono::minutes{1}},
                     {"minutes", std::chrono::minutes{1}}}};
 
    size_t num_end = 0;
    while (num_end < duration.size() && std::isdigit(duration[num_end])) {
        ++num_end;
    }
 
    if (num_end == 0 or num_end == duration.size()) {
        return std::nullopt;
    }
 
    std::string_view num_str = duration.substr(0, num_end);
    std::string_view unit_str = duration.substr(num_end);
 
    while (std::iswspace(unit_str[0])) {
        unit_str = unit_str.substr(1);
        if (unit_str.size() == 0) {
            return std::nullopt;
        }
    }
 
    try {
        uint64_t value = std::stoul(std::string(num_str));
        for (const auto& [unit, duration_unit] : unit_map) {
            if (unit_str.starts_with(unit)) {
                return std::chrono::nanoseconds(value * duration_unit.count());
            }
        }
    } catch (...) {
        return std::nullopt;
    }
 
    return std::nullopt;
}
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TIME_HPP