DateTimeFormat.h

Go to the documentation of this file.

#ifndef LINTEL_CORE_UTILS_DATETIMEFORMAT_H
#define LINTEL_CORE_UTILS_DATETIMEFORMAT_H
 
#include <cctype>
#include <charconv>
#include <chrono>
#include <cstdio>
#include <ctime>
#include <string>
 
#include "lintel/core/platform/Platform.h"
 
namespace lintel {
namespace datetime {
 
  using SystemTime = std::chrono::sys_time<std::chrono::microseconds>;
 
  inline std::time_t timegmPortable(std::tm *tm) noexcept
  {
#if defined(_WIN32)
    return ::_mkgmtime(tm);
#else
    return ::timegm(tm);
#endif
  }
 
  inline long localOffsetSeconds(std::time_t time, const std::tm &local) noexcept
  {
    // offset = local_wall_clock - utc_wall_clock = mktime(local) - timegm(local)
    // and mktime(local) == time, so the round trip through timegm() is enough.
    std::tm asUtc = local;
    return static_cast<long>(time - timegmPortable(&asUtc));
  }
 
  inline bool isEastOfUtc(long offsetSeconds) noexcept { return offsetSeconds >= 0; }
 
  inline std::string formatOffset(long offsetSeconds)
  {
    const long absolute = offsetSeconds < 0 ? -offsetSeconds : offsetSeconds;
    char buffer[16];
    const int written = std::snprintf(buffer,
      sizeof(buffer),
      "%c%02ld:%02ld",
      isEastOfUtc(offsetSeconds) ? '+' : '-',
      absolute / 3600,
      (absolute % 3600) / 60);
    if (written < 0) { return {}; }
    return std::string(buffer, static_cast<std::size_t>(written));
  }
 
  inline std::string formatSystemTime(const SystemTime &value, char dateSeparator = '-')
  {
    const auto wholeSeconds = std::chrono::floor<std::chrono::seconds>(value);
    const auto micros = std::chrono::duration_cast<std::chrono::microseconds>(value - wholeSeconds).count();
    const std::time_t time = std::chrono::system_clock::to_time_t(
      std::chrono::time_point_cast<std::chrono::system_clock::duration>(wholeSeconds));
    std::tm local{};
    if (!lintel::localTime(time, local)) { return {}; }
    const long offset = localOffsetSeconds(time, local);
 
    char buffer[64];
    const int written = std::snprintf(buffer,
      sizeof(buffer),
      "%04d%c%02d%c%02d %02d:%02d:%02d.%06ld",
      local.tm_year + 1900,
      dateSeparator,
      local.tm_mon + 1,
      dateSeparator,
      local.tm_mday,
      local.tm_hour,
      local.tm_min,
      local.tm_sec,
      static_cast<long>(micros));
    if (written < 0) { return {}; }
    return std::string(buffer, static_cast<std::size_t>(written)) + formatOffset(offset);
  }
 
  inline SystemTime parseSystemTime(const std::string &value)
  {
    int year = 0;
    int month = 0;
    int day = 0;
    int hour = 0;
    int minute = 0;
    int second = 0;
 
    // The date/time fields are converted with std::from_chars: std::sscanf cannot
    // report invalid input or overflow (cert-err34-c).
    const auto readInt = [&value](std::size_t &position, int &result) {
      const auto parsed = std::from_chars(value.data() + position, value.data() + value.size(), result);
      if (parsed.ec != std::errc{} || parsed.ptr == value.data() + position) { return false; }
      position = static_cast<std::size_t>(parsed.ptr - value.data());
      return true;
    };
    const auto readField = [&value, &readInt](std::size_t &position, char separator, int &result) {
      if (!readInt(position, result)) { return false; }
      if (position >= value.size() || value[position] != separator) { return false; }
      ++position;
      return true;
    };
 
    std::size_t index = 0;
    const bool parsedDate = readField(index, '-', year) && readField(index, '-', month) && readField(index, ' ', day);
    const bool parsedTime = readField(index, ':', hour) && readField(index, ':', minute) && readInt(index, second);
    if (!parsedDate || !parsedTime) { return SystemTime{}; }
    long micros = 0;
    if (index < value.size() && value[index] == '.') {
      ++index;
      long scale = 100000;
      while (index < value.size() && std::isdigit(static_cast<unsigned char>(value[index])) != 0) {
        if (scale > 0) {
          micros += static_cast<long>(value[index] - '0') * scale;
          scale /= 10;
        }
        ++index;
      }
    }
 
    // The offset is mandatory (PostgreSQL/SQLite always write one). "Z" means UTC.
    long offsetSeconds = 0;
    if (index < value.size() && (value[index] == 'Z' || value[index] == 'z')) {
      ++index;
    } else if (index < value.size() && (value[index] == '+' || value[index] == '-')) {
      const bool negative = value[index] == '-';
      ++index;
      const auto readNumber = [&value, &index](int maxDigits) -> int {
        int result = 0;
        int digits = 0;
        while (
          index < value.size() && digits < maxDigits && std::isdigit(static_cast<unsigned char>(value[index])) != 0) {
          result = result * 10 + (value[index] - '0');
          ++index;
          ++digits;
        }
        return result;
      };
      const int offsetHours = readNumber(2);
      if (index < value.size() && value[index] == ':') { ++index; }
      const int offsetMinutes = readNumber(2);
      offsetSeconds = static_cast<long>(offsetHours) * 3600 + static_cast<long>(offsetMinutes) * 60;
      if (negative) { offsetSeconds = -offsetSeconds; }
    } else {
      return SystemTime{};
    }
 
    std::tm tm{};
    tm.tm_year = year - 1900;
    tm.tm_mon = month - 1;
    tm.tm_mday = day;
    tm.tm_hour = hour;
    tm.tm_min = minute;
    tm.tm_sec = second;
    tm.tm_isdst = 0;
    const std::time_t utcSeconds = timegmPortable(&tm) - offsetSeconds;
    return SystemTime{ std::chrono::seconds{ utcSeconds } } + std::chrono::microseconds{ micros };
  }
 
  inline std::string formatUtcIsoSeconds(const std::chrono::sys_seconds &value)
  {
    const std::time_t time =
      std::chrono::system_clock::to_time_t(std::chrono::time_point_cast<std::chrono::system_clock::duration>(value));
    std::tm utc{};
#if defined(_WIN32)
    if (::gmtime_s(&utc, &time) != 0) { return {}; }
#else
    if (::gmtime_r(&time, &utc) == nullptr) { return {}; }
#endif
    char buffer[32];
    const int written = std::snprintf(buffer,
      sizeof(buffer),
      "%04d-%02d-%02dT%02d:%02d:%02dZ",
      utc.tm_year + 1900,
      utc.tm_mon + 1,
      utc.tm_mday,
      utc.tm_hour,
      utc.tm_min,
      utc.tm_sec);
    if (written < 0) { return {}; }
    return std::string(buffer, static_cast<std::size_t>(written));
  }
 
}// namespace datetime
}// namespace lintel
 
#endif// LINTEL_CORE_UTILS_DATETIMEFORMAT_H