function-comparators-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_FUNCTION_COMPARATORS_INLINES_H_
#define MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_FUNCTION_COMPARATORS_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
 
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif // defined(__clang__)
#endif // defined(__GNUC__)
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::equal, Lhs_T,
                                         Rhs_T>
  constexpr auto
  eq (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::equal_to{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<detail::comparison::equal, Lhs_T,
                                              Rhs_T>)
  constexpr bool
  eq ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::equal, Lhs_T, Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::not_equal, Lhs_T,
                                         Rhs_T>
  constexpr auto
  ne (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::not_equal_to{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<detail::comparison::not_equal,
                                              Lhs_T, Rhs_T>)
  constexpr bool
  ne ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::not_equal, Lhs_T, Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::greater, Lhs_T,
                                         Rhs_T>
  constexpr auto
  gt (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::greater{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<detail::comparison::greater,
                                              Lhs_T, Rhs_T>)
  constexpr bool
  gt ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::greater, Lhs_T, Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::greater_equal,
                                         Lhs_T, Rhs_T>
  constexpr auto
  ge (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::greater_equal{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<
              detail::comparison::greater_equal, Lhs_T, Rhs_T>)
  constexpr bool
  ge ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::greater_equal, Lhs_T,
                              Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::less, Lhs_T,
                                         Rhs_T>
  constexpr auto
  lt (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::less{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<detail::comparison::less, Lhs_T,
                                              Rhs_T>)
  constexpr bool
  lt ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::less, Lhs_T, Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T>
    requires detail::comparable_operands<detail::comparison::less_equal, Lhs_T,
                                         Rhs_T>
  constexpr auto
  le (Lhs_T&& lhs, Rhs_T&& rhs)
  {
    return detail::compare_op{ detail::as_operand (std::forward<Lhs_T> (lhs)),
                               detail::as_operand (std::forward<Rhs_T> (rhs)),
                               detail::less_equal{} };
  }
 
#if !defined(__DOXYGEN__)
  template <class Lhs_T, class Rhs_T>
    requires (not detail::comparable_operands<detail::comparison::less_equal,
                                              Lhs_T, Rhs_T>)
  constexpr bool
  le ([[maybe_unused]] Lhs_T&& lhs, [[maybe_unused]] Rhs_T&& rhs)
  {
    detail::reject_comparison<detail::comparison::less_equal, Lhs_T, Rhs_T> ();
    return false;
  }
#endif // !defined(__DOXYGEN__)

  template <class Lhs_T, class Rhs_T, class Epsilon_T>
    requires (extension::approx_operand<Lhs_T>
              and extension::approx_operand<Rhs_T>
              and extension::approx_operand<Epsilon_T>)
  constexpr auto
  approx (Lhs_T&& lhs, Rhs_T&& rhs, Epsilon_T&& epsilon)
  {
    return detail::approx_op{ std::forward<Lhs_T> (lhs),
                              std::forward<Rhs_T> (rhs),
                              std::forward<Epsilon_T> (epsilon) };
  }
 
  // --------------------------------------------------------------------------
  // Logical operators.

  template <class Expr_T>
    requires extension::checkable<std::remove_cvref_t<Expr_T>>
  constexpr auto
  negate (Expr_T&& expr)
  {
    return detail::not_op<detail::stored_operand_t<Expr_T>>{
      std::forward<Expr_T> (expr)
    };
  }

  template <class First_T, class Second_T, class... Rest_T>
    requires (extension::checkable<std::remove_cvref_t<First_T>>
              and extension::checkable<std::remove_cvref_t<Second_T>>
              and (extension::checkable<std::remove_cvref_t<Rest_T>> and ...))
  constexpr auto
  all_of (First_T&& first, Second_T&& second, Rest_T&&... rest)
  {
    if constexpr (sizeof...(Rest_T) == 0)
      {
        return detail::and_op{ std::forward<First_T> (first),
                               std::forward<Second_T> (second) };
      }
    else
      {
        return micro_test_plus::all_of (
            detail::and_op{ std::forward<First_T> (first),
                            std::forward<Second_T> (second) },
            std::forward<Rest_T> (rest)...);
      }
  }

  template <class First_T, class Second_T, class... Rest_T>
    requires (extension::checkable<std::remove_cvref_t<First_T>>
              and extension::checkable<std::remove_cvref_t<Second_T>>
              and (extension::checkable<std::remove_cvref_t<Rest_T>> and ...))
  constexpr auto
  any_of (First_T&& first, Second_T&& second, Rest_T&&... rest)
  {
    if constexpr (sizeof...(Rest_T) == 0)
      {
        return detail::or_op{ std::forward<First_T> (first),
                              std::forward<Second_T> (second) };
      }
    else
      {
        return micro_test_plus::any_of (
            detail::or_op{ std::forward<First_T> (first),
                           std::forward<Second_T> (second) },
            std::forward<Rest_T> (rest)...);
      }
  }
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__)
 
// ----------------------------------------------------------------------------
 
#endif // defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_OS_PLUS_MICRO_TEST_PLUS_INLINES_FUNCTION_COMPARATORS_INLINES_H_
 
// ----------------------------------------------------------------------------