micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T > Struct Template Reference

Non-equality comparator struct template. More...

#include <micro-os-plus/micro-test-plus.h>

Inheritance diagram for micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >:

Public Member Functions
constexpr	ne_ (const Lhs_T &lhs={}, const Rhs_T &rhs={})
	Constructs a non-equality comparator for the given operands.
constexpr auto	lhs (void) const
	Retrieves the left-hand operand.
constexpr	operator bool () const
	Conversion operator to boolean.
constexpr auto	rhs (void) const
	Retrieves the right-hand operand.

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

Detailed Description

template<class Lhs_T, class Rhs_T>
struct micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >

Template Parameters

Lhs_T	The type of the left-hand operand.
Rhs_T	The type of the right-hand operand.

The ne_ struct template provides a type-safe mechanism for evaluating non-equality between two operands within the framework.

This comparator supports a variety of operand types, including those with static values, types with precision (epsilon), and generic types. For types with static values, the comparison is performed directly. For types supporting precision, the comparison accounts for the smallest epsilon to ensure accuracy, particularly for floating-point types. For all other types, the generic getter is used to retrieve and compare the values.

The implementation is optimised for use in embedded environments and supports both compile-time and run-time evaluation.

All definitions are intended for internal use within the framework and are implemented in the include/micro-os-plus folder to maintain a structured and modular codebase.

Definition at line 437 of file detail.h.

Constructor & Destructor Documentation

ne_()

template<class Lhs_T, class Rhs_T>

micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::ne_ ( const Lhs_T & lhs = {}, const Rhs_T & rhs = {} )

inlineconstexpr

Parameters

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

Evaluates the non-equality of the provided operands at construction, supporting static values, types with precision, and generic types. The result is stored in the value_ member for efficient access.

Definition at line 450 of file detail.h.

                                        {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs }, value_{
              [&]
                {
                  using std::operator==;
                  using std::operator!=;
                  using std::operator>;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                  if constexpr (type_traits::has_value_v<Lhs_T>
                                and type_traits::has_value_v<Rhs_T>)
                    {
                      return Lhs_T::value != Rhs_T::value;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
                                     and type_traits::has_epsilon_v<Rhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > math::min_value (Lhs_T::epsilon,
                                                Rhs_T::epsilon);
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > Lhs_T::epsilon;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > Rhs_T::epsilon;
                    }
                  else
                    {
                      return get (lhs_) != get (rhs_);
                    }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                }()
            }
      {
      }

References lhs().

Member Function Documentation

lhs()

template<class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::lhs ( void ) const

inlinenodiscardconstexpr

Parameters

None.

Returns

The extracted left-hand operand.

Returns the value of the left-hand operand, applying the generic getter to ensure correct extraction for both custom and standard types.

Definition at line 533 of file detail.h.

      {
        return get (lhs_);
      }

References micro_os_plus::micro_test_plus::detail::get(), and lhs_.

Referenced by ne_(), and micro_os_plus::micro_test_plus::test_reporter::operator<<().

operator bool()

template<class Lhs_T, class Rhs_T>

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

inlinenodiscardconstexpr

Parameters

None.

Return values

true	The operands are considered not equal.
false	The operands are considered equal.

Returns the result of the non-equality comparison.

Definition at line 515 of file detail.h.

      {
        return value_;
      }

References value_.

rhs()

template<class Lhs_T, class Rhs_T>

auto micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::rhs ( void ) const

inlinenodiscardconstexpr

Parameters

None.

Returns

The extracted right-hand operand.

Returns the value of the right-hand operand, applying the generic getter to ensure correct extraction for both custom and standard types.

Definition at line 551 of file detail.h.

      {
        return get (rhs_);
      }

References micro_os_plus::micro_test_plus::detail::get(), and rhs_.

Referenced by micro_os_plus::micro_test_plus::test_reporter::operator<<().

Member Data Documentation

lhs_

template<class Lhs_T, class Rhs_T>

const Lhs_T micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::lhs_ {}

Definition at line 559 of file detail.h.

{};

Referenced by lhs().

rhs_

template<class Lhs_T, class Rhs_T>

const Rhs_T micro_os_plus::micro_test_plus::detail::ne_< Lhs_T, Rhs_T >::rhs_ {}

Definition at line 564 of file detail.h.

{};

Referenced by rhs().

value_

template<class Lhs_T, class Rhs_T>

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

Definition at line 569 of file detail.h.

{};

Referenced by operator bool().

---

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

• detail.h