posix_time.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt.hpp"
#include <cstdint>
#include <type_traits>
 
namespace microfmt {
 
// ============================================================================
// Structural Traits for POSIX Time Types
// ============================================================================
 
namespace detail {
 
template <typename T, typename = void> struct is_timespec_like : std::false_type {};
 
template <typename T>
struct is_timespec_like<T, std::void_t<decltype(std::declval<T>().tv_sec), decltype(std::declval<T>().tv_nsec)>>
    : std::true_type {};
 
template <typename T, typename = void> struct is_timeval_like : std::false_type {};
 
template <typename T>
struct is_timeval_like<T, std::void_t<decltype(std::declval<T>().tv_sec), decltype(std::declval<T>().tv_usec)>>
    : std::true_type {};
 
} // namespace detail
 
template <typename T>
inline constexpr bool is_timespec_v = detail::is_timespec_like<std::remove_cv_t<std::remove_reference_t<T>>>::value;
 
template <typename T>
inline constexpr bool is_timeval_v = detail::is_timeval_like<std::remove_cv_t<std::remove_reference_t<T>>>::value;
 
// ============================================================================
// Formatter for struct timespec (.tv_sec, .tv_nsec)
// ============================================================================
 
template <typename T> struct formatter<T, std::enable_if_t<is_timespec_v<T>>> {
  uint8_t precision{9}; // default: 9 digits (nanoseconds)
  bool show_unit{true}; // 'r' -> raw numbers without 's' suffix
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (!spec.empty() && spec.front() == ':') {
      spec.remove_prefix(1);
    }
    for (char c : spec) {
      if (c == 'm' || c == '3')
        precision = 3;
      else if (c == 'u' || c == '6')
        precision = 6;
      else if (c == 'n' || c == '9')
        precision = 9;
      else if (c == 'r' || c == 'R')
        show_unit = false;
    }
  }
 
  // time-field arithmetic converts between C/POSIX integer widths whose ranges are bounded by the format.
  RELOCO_BEGIN_UNSAFE_CODE
  void format(const T &ts, const sink &out) const noexcept {
    int64_t sec = static_cast<int64_t>(ts.tv_sec);
    uint32_t nsec = static_cast<uint32_t>(ts.tv_nsec);
 
    if (sec < 0) {
      out.put('-');
      detail::format_unsigned<detail::radix::decimal>(out, static_cast<uint64_t>(-sec), false, 0);
    } else {
      detail::format_unsigned<detail::radix::decimal>(out, static_cast<uint64_t>(sec), false, 0);
    }
 
    out.put('.');
    if (precision == 3) {
      detail::format_unsigned<detail::radix::decimal>(out, nsec / 1'000'000, false, 3);
    } else if (precision == 6) {
      detail::format_unsigned<detail::radix::decimal>(out, nsec / 1'000, false, 6);
    } else {
      detail::format_unsigned<detail::radix::decimal>(out, nsec, false, 9);
    }
 
    if (show_unit) {
      out.put('s');
    }
  }
  RELOCO_END_UNSAFE_CODE
};
 
// ============================================================================
// Formatter for struct timeval (.tv_sec, .tv_usec)
// ============================================================================
 
template <typename T> struct formatter<T, std::enable_if_t<is_timeval_v<T>>> {
  uint8_t precision{6}; // default: 6 digits (microseconds)
  bool show_unit{true};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (!spec.empty() && spec.front() == ':') {
      spec.remove_prefix(1);
    }
    for (char c : spec) {
      if (c == 'm' || c == '3')
        precision = 3;
      else if (c == 'u' || c == '6')
        precision = 6;
      else if (c == 'r' || c == 'R')
        show_unit = false;
    }
  }
 
  // time-field arithmetic converts between C/POSIX integer widths whose ranges are bounded by the format.
  RELOCO_BEGIN_UNSAFE_CODE
  void format(const T &tv, const sink &out) const noexcept {
    int64_t sec = static_cast<int64_t>(tv.tv_sec);
    uint32_t usec = static_cast<uint32_t>(tv.tv_usec);
 
    if (sec < 0) {
      out.put('-');
      detail::format_unsigned<detail::radix::decimal>(out, static_cast<uint64_t>(-sec), false, 0);
    } else {
      detail::format_unsigned<detail::radix::decimal>(out, static_cast<uint64_t>(sec), false, 0);
    }
 
    out.put('.');
    if (precision == 3) {
      detail::format_unsigned<detail::radix::decimal>(out, usec / 1'000, false, 3);
    } else {
      detail::format_unsigned<detail::radix::decimal>(out, usec, false, 6);
    }
 
    if (show_unit) {
      out.put('s');
    }
  }
  RELOCO_END_UNSAFE_CODE
};
 
} // namespace microfmt