units.ccm

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

module;
#include <chrono>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <ratio>
#include <type_traits>
 
export module jam:units;
 
namespace jam::units::detail {
[[noreturn]] inline void overflow() noexcept {
  std::fputs("jam: space arithmetic overflow or invalid conversion\n", stderr);
  std::abort();
}
 
template<class To, class From, class Scale = std::ratio<1>>
constexpr To convert(From value) noexcept {
  if constexpr (std::integral<To> && std::integral<From>) {
    // A 64-bit count times an intmax_t ratio fits this signed intermediate.
    auto const scaled = static_cast<__int128>(value) * Scale::num / Scale::den;
    if (scaled < static_cast<__int128>(std::numeric_limits<To>::lowest()) ||
        scaled > static_cast<__int128>(std::numeric_limits<To>::max())) overflow();
    return static_cast<To>(scaled);
  } else {
    auto const scaled = static_cast<long double>(value) * Scale::num / Scale::den;
    if constexpr (std::integral<To>) {
      // Truncate before checking the destination, including -0.5 -> unsigned 0.
      // This loose exact bound makes the intermediate float-to-integer cast safe.
      constexpr auto bound = static_cast<long double>(__int128{1} << 65);
      if (!std::isfinite(scaled) || scaled <= -bound || scaled >= bound) overflow();
      auto const integral = static_cast<__int128>(scaled);
      if (integral < static_cast<__int128>(std::numeric_limits<To>::lowest()) ||
          integral > static_cast<__int128>(std::numeric_limits<To>::max())) overflow();
      return static_cast<To>(integral);
    }
    return static_cast<To>(scaled);
  }
}
 
template<char Op, class R>
constexpr R arithmetic(R a, R b) noexcept {
  if constexpr (std::integral<R>) {
    R result;
    if constexpr (Op == '+') { if (__builtin_add_overflow(a, b, &result)) overflow(); }
    if constexpr (Op == '-') { if (__builtin_sub_overflow(a, b, &result)) overflow(); }
    if constexpr (Op == '*') { if (__builtin_mul_overflow(a, b, &result)) overflow(); }
    if constexpr (Op == '/' || Op == '%') {
      if (!b) overflow();
      if constexpr (std::is_signed_v<R>)
        if (a == std::numeric_limits<R>::lowest() && b == -1) overflow();
      if constexpr (Op == '/') result = a / b;
      else result = a % b;
    }
    return result;
  } else {
    if constexpr (Op == '+') return a + b;
    if constexpr (Op == '-') return a - b;
    if constexpr (Op == '*') return a * b;
    if constexpr (Op == '/') return a / b;
  }
}
}
 
export namespace jam::units {
template<class Rep, class Ratio = std::ratio<1>>
class space {
  static_assert(std::is_arithmetic_v<Rep> && !std::same_as<Rep, bool> && sizeof(Rep) <= sizeof(long double));
  static_assert(!std::integral<Rep> || sizeof(Rep) <= sizeof(std::uint64_t));
  static_assert(Ratio::num > 0);
  Rep value;
public:
  using rep = Rep; 
  using ratio = typename Ratio::type; 
  constexpr space() = default;
  template<class R>
    requires std::is_arithmetic_v<R> && (std::floating_point<Rep> || !std::floating_point<R>)
  constexpr explicit space(R count) noexcept : value(detail::convert<Rep>(count)) {}
  template<class R, class P>
    requires (std::floating_point<Rep> ||
      (!std::floating_point<R> && std::ratio_divide<P, ratio>::den == 1))
  constexpr space(space<R, P> other) noexcept
    : value(detail::convert<Rep, R, std::ratio_divide<P, ratio>>(other.count())) {}

  [[nodiscard]] constexpr rep count() const noexcept { return value; }
  [[nodiscard]] static constexpr space zero() noexcept { return space{rep{0}}; }
  [[nodiscard]] static constexpr space min() noexcept { return space{std::numeric_limits<rep>::lowest()}; }
  [[nodiscard]] static constexpr space max() noexcept { return space{std::numeric_limits<rep>::max()}; }
  [[nodiscard]] constexpr space operator+() const noexcept { return *this; }
  [[nodiscard]] constexpr space operator-() const noexcept { return space{detail::arithmetic<'-'>(rep{0}, value)}; }
  constexpr space & operator++() noexcept { return *this += space{1}; }
  constexpr space operator++(int) noexcept { auto old = *this; ++*this; return old; }
  constexpr space & operator--() noexcept { return *this -= space{1}; }
  constexpr space operator--(int) noexcept { auto old = *this; --*this; return old; }
  constexpr space & operator+=(space other) noexcept { value = detail::arithmetic<'+'>(value, other.value); return *this; }
  constexpr space & operator-=(space other) noexcept { value = detail::arithmetic<'-'>(value, other.value); return *this; }
  constexpr space & operator*=(rep scalar) noexcept { value = detail::arithmetic<'*'>(value, scalar); return *this; }
  constexpr space & operator/=(rep scalar) noexcept { value = detail::arithmetic<'/'>(value, scalar); return *this; }
  constexpr space & operator%=(rep scalar) noexcept requires std::integral<rep> { value = detail::arithmetic<'%'>(value, scalar); return *this; }
  constexpr space & operator%=(space other) noexcept requires std::integral<rep> { return *this %= other.value; }
};
}
 
export namespace std {
template<class R1, class P1, class R2, class P2>
struct common_type<jam::units::space<R1, P1>, jam::units::space<R2, P2>> {
  using duration = common_type_t<chrono::duration<R1, P1>, chrono::duration<R2, P2>>;
  using type = jam::units::space<typename duration::rep, typename duration::period>;
};
}
 
export namespace jam::units {
template<class To, class R, class P>
[[nodiscard]] constexpr To space_cast(space<R, P> value) noexcept {
  return To{detail::convert<typename To::rep, R, std::ratio_divide<P, typename To::ratio>>(value.count())};
}

template<class R1, class P1, class R2, class P2>
[[nodiscard]] constexpr auto operator<=>(space<R1, P1> a, space<R2, P2> b) noexcept {
  if constexpr (std::integral<R1> && std::integral<R2>) {
    using Scale = std::ratio_divide<P1, P2>;
    return (static_cast<__int128>(a.count()) * Scale::num)
       <=> (static_cast<__int128>(b.count()) * Scale::den);
  } else {
    using C = std::common_type_t<decltype(a), decltype(b)>;
    return C{a}.count() <=> C{b}.count();
  }
}

template<class R1, class P1, class R2, class P2>
[[nodiscard]] constexpr bool operator==(space<R1, P1> a, space<R2, P2> b) noexcept { return (a <=> b) == 0; }
template<class R1, class P1, class R2, class P2>
[[nodiscard]] constexpr auto operator+(space<R1, P1> a, space<R2, P2> b) noexcept {
  using C = std::common_type_t<decltype(a), decltype(b)>;
  return C{a} += C{b};
}

template<class R1, class P1, class R2, class P2>
[[nodiscard]] constexpr auto operator-(space<R1, P1> a, space<R2, P2> b) noexcept {
  using C = std::common_type_t<decltype(a), decltype(b)>;
  return C{a} -= C{b};
}

template<class R, class P, class S> requires std::is_arithmetic_v<S>
[[nodiscard]] constexpr auto operator*(space<R, P> a, S b) noexcept {
  return space<std::common_type_t<R, S>, P>{a} *= b;
}

template<class R, class P, class S> requires std::is_arithmetic_v<S>
[[nodiscard]] constexpr auto operator*(S a, space<R, P> b) noexcept { return b * a; }
template<class R, class P, class S> requires std::is_arithmetic_v<S>
[[nodiscard]] constexpr auto operator/(space<R, P> a, S b) noexcept {
  return space<std::common_type_t<R, S>, P>{a} /= b;
}

template<class R1, class P1, class R2, class P2>
[[nodiscard]] constexpr auto operator/(space<R1, P1> a, space<R2, P2> b) noexcept {
  using C = std::common_type_t<decltype(a), decltype(b)>;
  return detail::arithmetic<'/'>(C{a}.count(), C{b}.count());
}

template<std::integral R, class P, std::integral S>
[[nodiscard]] constexpr auto operator%(space<R, P> a, S b) noexcept { return space<std::common_type_t<R, S>, P>{a} %= b; }
template<std::integral R1, class P1, std::integral R2, class P2>
[[nodiscard]] constexpr auto operator%(space<R1, P1> a, space<R2, P2> b) noexcept {
  using C = std::common_type_t<decltype(a), decltype(b)>;
  return C{a} %= C{b};
}

template<class To, class R, class P>
[[nodiscard]] constexpr To floor(space<R, P> value) noexcept {
  auto result = space_cast<To>(value);
  if (result > value) --result;
  return result;
}

template<class To, class R, class P>
[[nodiscard]] constexpr To ceil(space<R, P> value) noexcept {
  auto result = space_cast<To>(value);
  if (result < value) ++result;
  return result;
}

template<class To, class R, class P> requires std::integral<typename To::rep>
[[nodiscard]] constexpr To round(space<R, P> value) noexcept {
  auto const lo = floor<To>(value);
  if (lo == value) return lo;
  auto hi = lo; ++hi;
  auto const down = value - lo, up = hi - value;
  return down < up || (down == up && lo.count() % 2 == 0) ? lo : hi;
}

template<class R, class P> requires std::is_signed_v<R>
[[nodiscard]] constexpr auto abs(space<R, P> value) noexcept { return value < value.zero() ? -value : value; }
 
using kibi = std::ratio<1024>; 
using mebi = std::ratio<1048576>; 
using gibi = std::ratio<1073741824>; 
using bytes = space<std::size_t>; 
using kilobytes = space<std::size_t, std::kilo>; 
using megabytes = space<std::size_t, std::mega>; 
using gigabytes = space<std::size_t, std::giga>; 
using kibibytes = space<std::size_t, kibi>; 
using mebibytes = space<std::size_t, mebi>; 
using gibibytes = space<std::size_t, gibi>; 
using pages = space<std::size_t, std::ratio<JAM_PAGE_BYTES>>; 
}
 
export namespace jam {
inline namespace literals {
[[nodiscard]] consteval units::bytes operator""_B(unsigned long long n) noexcept { return units::bytes{n}; }
[[nodiscard]] consteval units::space<long double, std::ratio<1>> operator""_B(long double n) noexcept { return units::space<long double, std::ratio<1>>{n}; }
[[nodiscard]] consteval units::kilobytes operator""_kB(unsigned long long n) noexcept { return units::kilobytes{n}; }
[[nodiscard]] consteval units::space<long double, std::kilo> operator""_kB(long double n) noexcept { return units::space<long double, std::kilo>{n}; }
[[nodiscard]] consteval units::megabytes operator""_MB(unsigned long long n) noexcept { return units::megabytes{n}; }
[[nodiscard]] consteval units::space<long double, std::mega> operator""_MB(long double n) noexcept { return units::space<long double, std::mega>{n}; }
[[nodiscard]] consteval units::gigabytes operator""_GB(unsigned long long n) noexcept { return units::gigabytes{n}; }
[[nodiscard]] consteval units::space<long double, std::giga> operator""_GB(long double n) noexcept { return units::space<long double, std::giga>{n}; }
[[nodiscard]] consteval units::kibibytes operator""_KiB(unsigned long long n) noexcept { return units::kibibytes{n}; }
[[nodiscard]] consteval units::space<long double, units::kibi> operator""_KiB(long double n) noexcept { return units::space<long double, units::kibi>{n}; }
[[nodiscard]] consteval units::mebibytes operator""_MiB(unsigned long long n) noexcept { return units::mebibytes{n}; }
[[nodiscard]] consteval units::space<long double, units::mebi> operator""_MiB(long double n) noexcept { return units::space<long double, units::mebi>{n}; }
[[nodiscard]] consteval units::gibibytes operator""_GiB(unsigned long long n) noexcept { return units::gibibytes{n}; }
[[nodiscard]] consteval units::space<long double, units::gibi> operator""_GiB(long double n) noexcept { return units::space<long double, units::gibi>{n}; }
}
}