deprecated-inlines.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can be
 * obtained from https://opensource.org/licenses/mit.
 *
 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
 * released under the terms of the Boost Version 1.0 Software License,
 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_DEPRECATED_INLINES_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_DEPRECATED_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#pragma GCC diagnostic ignored "-Waggregate-return"
#pragma GCC diagnostic ignored "-Wconversion"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wpre-c++17-compat"
#pragma clang diagnostic ignored "-Wc++20-compat"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------
  namespace detail::math
  {
    template <class T, class Exp_T>
    constexpr auto
    pow (const T base, const Exp_T exp) noexcept -> T
    {
      T result{ 1 };
      for (Exp_T i{}; i < exp; ++i)
        result *= base;
      return result;
    }

    template <bool Fraction, char... Cs>
    consteval auto
    count_literal_digits (void) -> std::size_t
    {
      std::size_t count = 0;
      bool is_fraction = false;
      for (const char c : { Cs... })
        {
          if (c == '.')
            {
              is_fraction = true;
            }
          else if (c >= '0' and c <= '9' and is_fraction == Fraction)
            {
              ++count;
            }
        }
      return count;
    }

    template <class T, char... Cs>
    consteval auto
    num (void) -> T
    {
      static_assert (
          ((Cs == '.' or Cs == '\'' or (Cs >= '0' and Cs <= '9')) and ...),
          "µTest++: a floating-point literal must be written with decimal "
          "digits and a decimal point, without an exponent");
      static_assert (
          count_literal_digits<false, Cs...> ()
              <= static_cast<std::size_t> (std::numeric_limits<T>::digits10),
          "µTest++: the floating-point literal has too many "
          "digits before the decimal point");
      T result{};
      for (const char c : { Cs... })
        {
          if (c == '.')
            {
              break;
            }
          if (c >= '0' and c <= '9')
            {
              result = static_cast<T> (result * static_cast<T> (10)
                                       + static_cast<T> (c - '0'));
            }
        }
      return result;
    }

    template <class T, char... Cs>
    consteval auto
    den (void) -> T
    {
      static_assert ((... || (Cs == '.')),
                     "den(): no decimal point in literal");
      // The result has as many digits as the decimals, and it must fit in
      // `T`.
      static_assert (
          count_literal_digits<true, Cs...> ()
              <= static_cast<std::size_t> (std::numeric_limits<T>::digits10),
          "µTest++: the floating-point literal has too many "
          "decimals");
      T result{};
      bool is_fraction = false;
      for (const char c : { Cs... })
        {
          if (c == '.')
            {
              is_fraction = true;
            }
          else if (is_fraction and c >= '0' and c <= '9')
            {
              // The digit separators are skipped.
              result = static_cast<T> (result * static_cast<T> (10)
                                       + static_cast<T> (c - '0'));
            }
        }
      return result;
    }

    template <class T, char... Cs>
    consteval auto
    den_size (void) -> T
    {
      static_assert ((... || (Cs == '.')),
                     "den_size(): no decimal point in literal");
      return static_cast<T> (count_literal_digits<true, Cs...> ());
    }

    template <class T, class Value_T>
    constexpr auto
    count_decimals (Value_T value) -> T
    {
      constexpr auto precision = Value_T (1e-7);
      // From this magnitude upwards all values are integers.
      constexpr auto integral_limit
          = min_value (Value_T (1) / std::numeric_limits<Value_T>::epsilon (),
                       Value_T (1ULL << 63));
 
      value = abs (value);
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif // defined(__GNUC__)
      if (value == Value_T (0))
        {
          // A zero has no decimals.
          return T{};
        }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
      T result{};
      for (;;)
        {
          value *= 10;
          ++result;
 
          // Also true for infinities and NaNs.
          if (not(value < integral_limit))
            {
              break;
            }
 
          const auto fraction = value
                                - static_cast<Value_T> (
                                    static_cast<unsigned long long> (value));
          // Below one, the distance is to one, not to zero, so that the
          // leading zeros of a small value are counted.
          const auto distance
              = (value < Value_T (1))
                    ? Value_T (1) - fraction
                    : min_value (fraction, Value_T (1) - fraction);
          if (distance <= precision)
            {
              break;
            }
        }
 
      return result;
    }

    template <class Value_T>
    constexpr auto
    decimal_epsilon (Value_T value) -> Value_T
    {
      const auto decimals = count_decimals<unsigned long long> (value);
      if (decimals == 0
          or decimals > static_cast<unsigned long long> (
                 std::numeric_limits<Value_T>::max_exponent10))
        {
          return Value_T{};
        }
      return Value_T (1) / pow (Value_T (10), decimals);
    }

    template <char... Cs>
    consteval auto
    parse_integer_literal (void) -> integer_literal
    {
      constexpr std::array<char, sizeof...(Cs)> cs{ Cs... };
      constexpr unsigned long long max_value
          = std::numeric_limits<unsigned long long>::max ();
 
      integer_literal result{ 0, true, false };
 
      unsigned long long base = 10;
      std::size_t i = 0;
      if (cs.size () > 1 && cs[0] == '0')
        {
          if (cs[1] == 'x' || cs[1] == 'X')
            {
              base = 16;
              i = 2;
            }
          else if (cs[1] == 'b' || cs[1] == 'B')
            {
              base = 2;
              i = 2;
            }
          else
            {
              base = 8;
              i = 1;
            }
        }
 
      for (; i < cs.size (); ++i)
        {
          const char c = cs[i];
          if (c == '\'')
            {
              continue;
            }
 
          unsigned long long digit = 0;
          if (c >= '0' && c <= '9')
            {
              digit = static_cast<unsigned long long> (c - '0');
            }
          else if (base == 16 && c >= 'a' && c <= 'f')
            {
              digit = static_cast<unsigned long long> (c - 'a' + 10);
            }
          else if (base == 16 && c >= 'A' && c <= 'F')
            {
              digit = static_cast<unsigned long long> (c - 'A' + 10);
            }
          else
            {
              // A decimal point, an exponent, or a suffix character.
              result.is_integer = false;
              return result;
            }
 
          if (digit >= base)
            {
              // Possible only in a floating-point literal, like `09.5`.
              result.is_integer = false;
              return result;
            }
 
          if (result.value > (max_value - digit) / base)
            {
              result.is_too_large = true;
              return result;
            }
 
          result.value = result.value * base + digit;
        }
 
      return result;
    }

    template <class T, char... Cs>
    consteval auto
    integer_magnitude (void) -> unsigned long long
    {
      constexpr integer_literal literal = parse_integer_literal<Cs...> ();
      constexpr unsigned long long max_magnitude
          = static_cast<unsigned long long> (std::numeric_limits<T>::max ())
            + (std::numeric_limits<T>::is_signed ? 1u : 0u);
      constexpr bool fits = literal.is_integer && !literal.is_too_large
                            && literal.value <= max_magnitude;
 
      static_assert (literal.is_integer,
                     "µTest++: an integer literal must not have a decimal "
                     "point or an exponent");
      static_assert (!literal.is_integer || !literal.is_too_large,
                     "µTest++: the integer literal is too large");
      static_assert (!literal.is_integer || literal.is_too_large || fits,
                     "µTest++: the integer literal value does not fit in the "
                     "type of the literal");
 
      return fits ? literal.value : 0;
    }
 
    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------
  } // namespace detail::math
 
  namespace detail
  {
    // ========================================================================

    template <class T>
    constexpr value_base<T>::value_base (const T& v) noexcept : value_{ v }
    {
    }

    template <class T>
    constexpr value_base<T>::
    operator T () const noexcept
    {
      return value_;
    }

    template <class T>
    constexpr const T&
    value_base<T>::get (void) const noexcept
    {
      return value_;
    }
 
    // ------------------------------------------------------------------------

    template <auto N>
    constexpr integral_constant<N>::integral_constant (void) noexcept
        : value_base<decltype (N)>{ N }
    {
    }

    template <auto N>
    constexpr auto
    integral_constant<N>::operator- () const noexcept
    {
      // Not named `value_type`, which would shadow the member inherited
      // from the base (`-Wshadow`).
      using constant_type = decltype (N);
 
      if constexpr (!std::is_signed_v<constant_type>)
        {
          return integral_constant<static_cast<constant_type> (constant_type{}
                                                               - N)>{};
        }
      else if constexpr (N == std::numeric_limits<constant_type>::min ())
        {
          static_assert (N != std::numeric_limits<constant_type>::min (),
                         "µTest++: the negation of the minimum value does "
                         "not fit in the type of the literal");
          return *this;
        }
      else
        {
          return integral_constant<static_cast<constant_type> (-N)>{};
        }
    }
 
    // ------------------------------------------------------------------------

    template <class T>
    constexpr auto
    integral_min_magnitude<T>::operator- () const noexcept
    {
      return integral_constant<std::numeric_limits<T>::min ()>{};
    }
 
    // ------------------------------------------------------------------------

    template <class T, char... Cs>
    constexpr auto
    integral_literal (void)
    {
      constexpr unsigned long long magnitude
          = math::integer_magnitude<T, Cs...> ();
 
      if constexpr (magnitude > static_cast<unsigned long long> (
                        std::numeric_limits<T>::max ()))
        {
          return integral_min_magnitude<T>{};
        }
      else
        {
          return integral_constant<static_cast<T> (magnitude)>{};
        }
    }
 
    // ------------------------------------------------------------------------

    template <class T, auto N, auto D, auto Size, auto P>
    constexpr floating_point_constant<T, N, D, Size, P>::
    operator T () const noexcept
    {
      return value;
    }

    template <class T, auto N, auto D, auto Size, auto P>
    constexpr T
    floating_point_constant<T, N, D, Size, P>::get (void) const noexcept
    {
      return value;
    }

    template <class T, auto N, auto D, auto Size, auto P>
    constexpr auto
    floating_point_constant<T, N, D, Size, P>::operator- () const noexcept
    {
      return floating_point_constant<T, N, D, Size, -P>{};
    }
 
    // ------------------------------------------------------------------------
 
    template <class T>
    constexpr value<T>::value (const T& _value) noexcept
        : value_base<T>{ _value }
    {
    }
 
    // ------------------------------------------------------------------------

    constexpr named_bool::named_bool (std::string_view name) noexcept
        : name_{ name }
    {
    }

    constexpr named_bool::
    operator value_type () const noexcept
    {
      return true;
    }

    constexpr std::string_view
    named_bool::name (void) const noexcept
    {
      return name_;
    }
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------

  // Deprecated since 6.0.0; use negate().
  template <class Expr_T>
  constexpr auto
  _not (Expr_T&& expr)
  {
    return negate (std::forward<Expr_T> (expr));
  }

  // Deprecated since 6.0.0; use all_of().
  template <class Lhs_T, class Rhs_T>
  constexpr auto
  _and (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return all_of (std::forward<Lhs_T> (lhs), std::forward<Rhs_T> (rhs));
  }

  // Deprecated since 6.0.0; use any_of().
  template <class Lhs_T, class Rhs_T>
  constexpr auto
  _or (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return any_of (std::forward<Lhs_T> (lhs), std::forward<Rhs_T> (rhs));
  }
 
  // --------------------------------------------------------------------------

  // Deprecated since 6.0.0; use const_cast<T&>.
  template <class T>
  constexpr auto
  mut (const T& t) noexcept -> T&
  {
    return const_cast<T&> (t);
  }
 
  // --------------------------------------------------------------------------
 
  namespace operators
  {
    // ========================================================================

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator== (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs),
                                 detail::equal_to{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator!= (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs),
                                 detail::not_equal_to{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator> (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs),
                                 detail::greater{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator>= (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs),
                                 detail::greater_equal{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator< (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs), detail::less{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator<= (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::compare_op{ std::forward<Lhs_T> (lhs),
                                 std::forward<Rhs_T> (rhs),
                                 detail::less_equal{} };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator and (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::and_op{ std::forward<Lhs_T> (lhs),
                             std::forward<Rhs_T> (rhs) };
    }

    template <class Lhs_T, class Rhs_T>
      requires extension::any_op<std::remove_cvref_t<Lhs_T>,
                                 std::remove_cvref_t<Rhs_T>>
    constexpr auto
    operator or (Lhs_T&& lhs, Rhs_T&& rhs)
    {
      return detail::or_op{ std::forward<Lhs_T> (lhs),
                            std::forward<Rhs_T> (rhs) };
    }

    template <class T>
      requires extension::is_op<std::remove_cvref_t<T>>
    constexpr auto
    operator not(T&& t)
    {
      // Not `not_op{ t }`, which would copy an operand that is itself
      // a `not_op`, instead of negating it.
      return detail::not_op<detail::stored_operand_t<T>>{ std::forward<T> (
          t) };
    }
 
    // ------------------------------------------------------------------------
  } // namespace operators
 
  // --------------------------------------------------------------------------
 
  namespace literals
  {

    template <char... Cs>
    constexpr auto
    operator""_i ()
    {
      return detail::integral_literal<int, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_s ()
    {
      return detail::integral_literal<short, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_c ()
    {
      return detail::integral_literal<char, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_sc ()
    {
      return detail::integral_literal<signed char, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_l ()
    {
      return detail::integral_literal<long, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_ll ()
    {
      return detail::integral_literal<long long, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_u ()
    {
      return detail::integral_literal<unsigned, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_uc ()
    {
      return detail::integral_literal<unsigned char, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_us ()
    {
      return detail::integral_literal<unsigned short, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_ul ()
    {
      return detail::integral_literal<unsigned long, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_ull ()
    {
      return detail::integral_literal<unsigned long long, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_i8 ()
    {
      return detail::integral_literal<std::int8_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_i16 ()
    {
      return detail::integral_literal<std::int16_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_i32 ()
    {
      return detail::integral_literal<std::int32_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_i64 ()
    {
      return detail::integral_literal<std::int64_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_u8 ()
    {
      return detail::integral_literal<std::uint8_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_u16 ()
    {
      return detail::integral_literal<std::uint16_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_u32 ()
    {
      return detail::integral_literal<std::uint32_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_u64 ()
    {
      return detail::integral_literal<std::uint64_t, Cs...> ();
    }

    template <char... Cs>
    constexpr auto
    operator""_f ()
    {
      return detail::floating_point_constant<
          float, detail::math::num<unsigned long long, Cs...> (),
          detail::math::den<unsigned long long, Cs...> (),
          detail::math::den_size<unsigned long long, Cs...> ()>{};
    }

    template <char... Cs>
    constexpr auto
    operator""_d ()
    {
      return detail::floating_point_constant<
          double, detail::math::num<unsigned long long, Cs...> (),
          detail::math::den<unsigned long long, Cs...> (),
          detail::math::den_size<unsigned long long, Cs...> ()>{};
    }

    template <char... Cs>
    constexpr auto
    operator""_ld ()
    {
      return detail::floating_point_constant<
          long double, detail::math::num<unsigned long long, Cs...> (),
          detail::math::den<unsigned long long, Cs...> (),
          detail::math::den_size<unsigned long long, Cs...> ()>{};
    }

    constexpr auto
    operator""_b (const char* name, decltype (sizeof ("")) size)
    {
      return detail::named_bool{ std::string_view{ name, size } };
    }
 
    // ------------------------------------------------------------------------
  } // namespace literals
 
  // ==========================================================================
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
// The definition of the deprecated class.
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__)

  template <class T>
  constexpr to_t<T>::to_t (const T& t) : detail::value<T>{ t }
  {
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)

  template <class T>
    requires std::is_floating_point_v<T>
  constexpr auto
  approx (T value, std::type_identity_t<T> epsilon) noexcept
      -> detail::value<T>
  {
    return detail::value<T>{ value, epsilon };
  }
 
} // namespace micro_os_plus::micro_test_plus
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus::detail
{
  // ==========================================================================

  // Deprecated since 6.0.0, as the whole `timestamp` class; the timings are
  // internal.
  inline timestamp::timestamp (const timespec& ts) noexcept : value_{ ts }
  {
  }

  // Deprecated since 6.0.0, as the whole `timestamp` class; the timings are
  // internal.
  inline bool
  timestamp::has_clock (void) const noexcept
  {
    return value_.tv_sec != 0 || value_.tv_nsec != 0;
  }

  // Deprecated since 6.0.0, as the whole `timestamp` class; the timings are
  // internal.
  inline timespec&
  timestamp::value (void) noexcept
  {
    return value_;
  }

  // Deprecated since 6.0.0, as the whole `timestamp` class; the timings are
  // internal.
  inline const timespec&
  timestamp::value (void) const noexcept
  {
    return value_;
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus::detail
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
 
// ----------------------------------------------------------------------------
 
#endif // defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_DEPRECATED_INLINES_H_
 
// ----------------------------------------------------------------------------