Relational comparator struct template. More...

#include "micro-os-plus/micro-test-plus.h"

Inheritance diagram for micro_os_plus::micro_test_plus::extension::compare_op< Lhs_T, Rhs_T, Compare_T >:

Public Types
using	op_type = op
	Marker identifying the framework expression types.

Public Member Functions
template<class L, class R> requires extension::compare_tag<Compare_T, unwrapped_t<L>, unwrapped_t<R>>
constexpr	compare_op (L &&lhs, R &&rhs, Compare_T)
	Constructs a comparator for the given operands.
constexpr decltype(auto)	lhs (void) const
	Retrieves the left-hand operand.
constexpr	operator bool () const
	Conversion operator to boolean.
constexpr decltype(auto)	rhs (void) const
	Retrieves the right-hand operand.

Private Attributes
Lhs_T	lhs_
	Stores the left-hand operand.
Rhs_T	rhs_
	Stores the right-hand operand.
const bool	value_ {}
	Stores the result of the comparison.

Detailed Description

template<class Lhs_T, class Rhs_T, class Compare_T>
struct micro_os_plus::micro_test_plus::extension::compare_op< Lhs_T, Rhs_T, Compare_T >

Derived from binary_op, this struct compares the left-hand operand with the right-hand operand, using the operator defined by the tag Compare_T (equal_to, not_equal_to, greater, greater_equal, less, or less_equal). It is used within test expressions to provide human-readable relational checks, with the actual and expected values, and the symbol of the tag, reported upon failure.

The tag is passed as an empty constructor argument, so that all three template arguments are deduced, for example compare_op{ lhs, rhs, equal_to{} }. A factory function would do the same, but at -O0 it adds one function per instantiation.

It is also public, as extension::compare_op, so that the applications can define their own comparisons with their own tags. A tag is an empty struct with:

a static constexpr const char* symbol, written between the operands in the failure reports, with the surrounding spaces (for example " divides ");
a static apply (lhs, rhs) member function template, which receives the unwrapped operands (the values of the to_* wrappers and of the literals) and returns the result as bool;
optionally, a static constexpr bool within_tolerance_result; when present, and an operand is a floating-point wrapper (see extension::has_epsilon), the operands within the tolerance give this result, as for the built-in comparators; when absent, the tolerance is ignored.

The operands are reported as the built-in comparators report them: the stored operands are prepared by as_operand(), so the C strings are written quoted, and the arrays as ranges; the tag still receives the operands as they were passed, without this conversion.

The temporaries are moved into the comparator, and the named operands are copied (see stored_operand_t), so a comparator built in a function from its const& parameters can be returned from it.

Template Parameters

Lhs_T	The type of the stored left-hand operand, either the operand type, or a const reference to it.
Rhs_T	The type of the stored right-hand operand, either the operand type, or a const reference to it.
Compare_T	The tag that defines the comparison. It is stateless, with a static symbol and a static apply(), so a parameter, such as a tolerance, is passed as an operand, usually the right one, and reported with the operands.

Definition at line 886 of file detail.h.

Member Typedef Documentation

◆ op_type

using micro_os_plus::micro_test_plus::detail::op::op_type = op

inherited

Detected by the extension::is_op concept, and inherited by all types derived from op.

Definition at line 128 of file extension.h.

Constructor & Destructor Documentation

◆ compare_op()

template<class Lhs_T, class Rhs_T, class Compare_T>
requires extension::compare_tag<Compare_T, unwrapped_t<L>, unwrapped_t<R>>

template<class L, class R>
requires extension::compare_tag<Compare_T, unwrapped_t<L>, unwrapped_t<R>>

micro_os_plus::micro_test_plus::detail::compare_op< Lhs_T, Rhs_T, Compare_T >::compare_op	(	L &&	lhs,
		R &&	rhs,
		Compare_T	)

constexpr

The result is computed from the arguments, before they are forwarded to the base. The tag argument is used only to deduce Compare_T.

Template Parameters

L	The type of the left-hand operand argument.
R	The type of the right-hand operand argument.

Parameters

lhs	The left-hand operand.
rhs	The right-hand operand.

Evaluates the comparison inside an immediately invoked lambda, which converts the result of Compare_T::apply() to bool, and passes it to the binary_op base class constructor:

for the framework constants with static value members (the numeric literals), the two values are compared directly;
if at least one operand is a framework floating-point wrapper with an epsilon member, and the tag defines a within_tolerance_result (all the built-in tags do), operands within the tolerance give this result; otherwise the unwrapped values are compared; the tags of the application without it ignore the tolerance;
for all other types, the framework wrappers are unwrapped, and the values, including the types of the application, are compared as they are.

Definition at line 855 of file detail-inlines.h.

        : binary_op<Lhs_T, Rhs_T>{ detail::as_operand (std::forward<L> (lhs)),
                                   detail::as_operand (std::forward<R> (rhs)),
                                   [&] () -> bool
      {
    // The result is computed before the arguments are moved, since
    // the base constructor is entered only after all its arguments
    // are evaluated.
#if defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
        using lhs_type = std::remove_cvref_t<L>;
        using rhs_type = std::remove_cvref_t<R>;
 
        if constexpr (detail::has_value<lhs_type>
                      and detail::has_value<rhs_type>)
          {
            return Compare_T::apply (lhs_type::value, rhs_type::value);
          }
        else if constexpr ((extension::has_epsilon<lhs_type>
                            or extension::has_epsilon<rhs_type>)
                           and requires {
                                 Compare_T::within_tolerance_result;
                               })
          {
            return detail::within_tolerance (lhs, rhs)
                       ? Compare_T::within_tolerance_result
                       : Compare_T::apply (detail::unwrap (lhs),
                                           detail::unwrap (rhs));
          }
        else
#endif // defined(MICRO_OS_PLUS_MICRO_TEST_PLUS_DEPRECATED_ENABLED)
          {
            return Compare_T::apply (detail::unwrap (lhs),
                                     detail::unwrap (rhs));
          }
      }() }
    {

Member Function Documentation

◆ lhs()

template<class Lhs_T, class Rhs_T>

decltype(auto) constexpr micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::lhs ( void ) const

nodiscardconstexprinherited

The operand is unwrapped with detail::unwrap() and returned by reference, so that formatting it does not copy it.

Parameters: None.

Returns: The extracted left-hand operand.

Returns the value of the left-hand operand, unwrapped by detail::unwrap() if it is a framework wrapper type; the stored operand is not copied.

Definition at line 181 of file detail-inlines.h.

    {
      return detail::unwrap (lhs_);
    }

References lhs(), lhs_, and micro_os_plus::micro_test_plus::detail::unwrap().

Referenced by micro_os_plus::micro_test_plus::detail::and_op< Lhs_T, Rhs_T >::and_op(), micro_os_plus::micro_test_plus::detail::approx_op< Lhs_T, Rhs_T, Epsilon_T >::approx_op(), binary_op(), micro_os_plus::micro_test_plus::detail::compare_op< Lhs_T, Rhs_T, Compare_T >::compare_op(), micro_os_plus::micro_test_plus::detail::or_op< Lhs_T, Rhs_T >::or_op(), and lhs().

◆ operator bool()

template<class Lhs_T, class Rhs_T>

micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::operator bool ( ) const

nodiscardconstexprinherited

Parameters: None.

Returns: The result of the comparison.

Returns the pre-computed boolean result stored by the derived comparator's constructor.

Definition at line 167 of file detail-inlines.h.

    {
      return value_;
    }

References binary_op(), and value_.

◆ rhs()

template<class Lhs_T, class Rhs_T>

decltype(auto) constexpr micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::rhs ( void ) const

nodiscardconstexprinherited

The operand is unwrapped with detail::unwrap() and returned by reference, so that formatting it does not copy it.

Parameters: None.

Returns: The extracted right-hand operand.

Returns the value of the right-hand operand, unwrapped by detail::unwrap() if it is a framework wrapper type; the stored operand is not copied.

Definition at line 194 of file detail-inlines.h.

    {
      return detail::unwrap (rhs_);
    }

References rhs(), rhs_, and micro_os_plus::micro_test_plus::detail::unwrap().

Referenced by micro_os_plus::micro_test_plus::detail::and_op< Lhs_T, Rhs_T >::and_op(), micro_os_plus::micro_test_plus::detail::approx_op< Lhs_T, Rhs_T, Epsilon_T >::approx_op(), binary_op(), micro_os_plus::micro_test_plus::detail::compare_op< Lhs_T, Rhs_T, Compare_T >::compare_op(), micro_os_plus::micro_test_plus::detail::or_op< Lhs_T, Rhs_T >::or_op(), and rhs().

Member Data Documentation

◆ lhs_

template<class Lhs_T, class Rhs_T>

Lhs_T micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::lhs_

privateinherited

A value, moved from a temporary or copied from a named operand, or, for a named operand that cannot be copied, a const reference to it (see stored_operand_t). It is not const, so that a temporary expression can be moved into an enclosing one.

Definition at line 410 of file detail.h.

Referenced by binary_op(), and lhs().

◆ rhs_

template<class Lhs_T, class Rhs_T>

Rhs_T micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::rhs_

privateinherited

Stored as the left-hand operand is.

Definition at line 418 of file detail.h.

Referenced by binary_op(), and rhs().

◆ value_

template<class Lhs_T, class Rhs_T>

const bool micro_os_plus::micro_test_plus::detail::binary_op< Lhs_T, Rhs_T >::value_ {}

privateinherited

Computed once, by the derived comparator constructor.

Definition at line 426 of file detail.h.

Referenced by binary_op(), and operator bool().

The documentation for this struct was generated from the following files:

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ op_type

Constructor & Destructor Documentation

◆ compare_op()

Member Function Documentation

◆ lhs()

◆ operator bool()

◆ rhs()

Member Data Documentation

◆ lhs_

◆ rhs_

◆ value_