bintime.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 <cstddef>
#include <cstdint>
#include <string_view>
#include <type_traits>
 
namespace microfmt {
 
// ============================================================================
// FreeBSD Time Type Traits
// ============================================================================
 
namespace detail {
 
// Primary detection: checks for struct with .sec and .frac members
template <typename T, typename = void> struct is_bintime_struct : std::false_type {};
 
template <typename T>
struct is_bintime_struct<T, std::void_t<decltype(std::declval<T>().sec), decltype(std::declval<T>().frac)>>
    : std::true_type {};
 
} // namespace detail
 
template <typename T> struct is_bintime : detail::is_bintime_struct<T> {};
 
template <typename T>
inline constexpr bool is_bintime_v = is_bintime<std::remove_cv_t<std::remove_reference_t<T>>>::value;
 
enum class time_precision : uint8_t { sec = 0, ms = 3, us = 6, ns = 9, ps = 12 };
 
// ============================================================================
// Zero-Float Scaling Helpers
// ============================================================================
 
namespace detail {
 
inline uint64_t bintime_frac_to_decimal(uint64_t frac, time_precision prec) noexcept {
  uint64_t multiplier = 1'000'000'000;
  switch (prec) {
  case time_precision::ms:
    multiplier = 1'000;
    break;
  case time_precision::us:
    multiplier = 1'000'000;
    break;
  case time_precision::ns:
    multiplier = 1'000'000'000;
    break;
  case time_precision::ps:
    multiplier = 1'000'000'000'000ULL;
    break;
  case time_precision::sec:
  default:
    return 0;
  }
 
  constexpr uint64_t half_mask = 0xFFFFFFFFULL;
  const uint64_t frac_low = frac & half_mask;
  const uint64_t frac_high = frac >> 32;
  const uint64_t multiplier_low = multiplier & half_mask;
  const uint64_t multiplier_high = multiplier >> 32;
 
  const uint64_t low_product = frac_low * multiplier_low;
  const uint64_t middle = frac_high * multiplier_low + (low_product >> 32);
  const uint64_t middle_low = middle & half_mask;
  const uint64_t middle_high = middle >> 32;
  const uint64_t cross = middle_low + frac_low * multiplier_high;
 
  return frac_high * multiplier_high + middle_high + (cross >> 32);
}
 
inline uint32_t sbintime_frac_to_decimal(uint32_t frac32, time_precision prec) noexcept {
  uint64_t multiplier = 1'000'000'000;
  switch (prec) {
  case time_precision::ms:
    multiplier = 1'000;
    break;
  case time_precision::us:
    multiplier = 1'000'000;
    break;
  case time_precision::ns:
    multiplier = 1'000'000'000;
    break;
  case time_precision::sec:
  case time_precision::ps:
  default:
    multiplier = 1'000'000'000;
    break;
  }
  return static_cast<uint32_t>((static_cast<uint64_t>(frac32) * multiplier) >> 32);
}
 
} // namespace detail
 
// ============================================================================
// Formatter for Any `is_bintime` Matching Type (e.g. native struct bintime)
// ============================================================================
 
template <typename T> struct formatter<T, std::enable_if_t<is_bintime_v<T>>> {
  time_precision precision{time_precision::ns};
  bool show_unit{true};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    for (char c : spec) {
      if (c == 'm' || c == '3')
        precision = time_precision::ms;
      else if (c == 'u' || c == '6')
        precision = time_precision::us;
      else if (c == 'n' || c == '9')
        precision = time_precision::ns;
      else if (c == 'p' || c == '1')
        precision = time_precision::ps;
      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 &bt, const sink &out) const noexcept {
    int64_t sec = static_cast<int64_t>(bt.sec);
    uint64_t frac = static_cast<uint64_t>(bt.frac);
 
    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);
    }
 
    if (precision != time_precision::sec) {
      out.put('.');
      uint64_t dec_frac = detail::bintime_frac_to_decimal(frac, precision);
      detail::format_unsigned<detail::radix::decimal>(out, dec_frac, false, static_cast<int>(precision));
    }
 
    if (show_unit) {
      out.put('s');
    }
  }
  RELOCO_END_UNSAFE_CODE
};
 
// ============================================================================
// sbintime_t Wrapper View (disambiguates from standard int64_t)
// ============================================================================
 
template <typename T> struct sbintime_view {
  int64_t sbt{0};
};
 
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
[[nodiscard]] constexpr auto as_sbintime(T val) noexcept {
  return sbintime_view<T>{static_cast<int64_t>(val)};
}
 
template <typename T> struct formatter<sbintime_view<T>> {
  time_precision precision{time_precision::us};
  bool show_unit{true};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    for (char c : spec) {
      if (c == 'm' || c == '3')
        precision = time_precision::ms;
      else if (c == 'u' || c == '6')
        precision = time_precision::us;
      else if (c == 'n' || c == '9')
        precision = time_precision::ns;
      else if (c == 'r' || c == 'R')
        show_unit = false;
    }
  }
 
  void format(const sbintime_view<T> &sv, const sink &out) const noexcept {
    const int64_t val = sv.sbt;
    uint64_t magnitude = 0;
    if (val < 0) {
      out.put('-');
      magnitude = static_cast<uint64_t>(-(val + 1)) + 1;
    } else {
      magnitude = static_cast<uint64_t>(val);
    }
 
    const uint64_t sec = magnitude >> 32;
    const uint32_t frac = static_cast<uint32_t>(magnitude & UINT64_C(0xFFFFFFFF));
 
    detail::format_unsigned<detail::radix::decimal>(out, sec, false, 0);
 
    if (precision != time_precision::sec) {
      out.put('.');
      uint32_t dec_frac = detail::sbintime_frac_to_decimal(frac, precision);
      detail::format_unsigned<detail::radix::decimal>(out, dec_frac, false, static_cast<int>(precision));
    }
 
    if (show_unit) {
      out.put('s');
    }
  }
};
 
} // namespace microfmt