micro_os_plus::micro_test_plus::extension::predicate_op< T, Predicate_T > Struct Template Reference

Unary predicate struct template. More...

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

Inheritance diagram for micro_os_plus::micro_test_plus::extension::predicate_op< T, Predicate_T >:

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

Public Member Functions
template<class U> requires extension::predicate_tag<Predicate_T, unwrapped_t<U>>
constexpr	predicate_op (U &&t, Predicate_T)
	Constructs a predicate for the given operand.
constexpr decltype(auto)	operand (void) const
	Retrieves the wrapped operand expression.
constexpr	operator bool () const
	Conversion operator to boolean.

Private Attributes
T	t_
	Stores the operand.
const bool	value_ {}
	Stores the result of the operation.

Detailed Description

template<class T, class Predicate_T>
struct micro_os_plus::micro_test_plus::extension::predicate_op< T, Predicate_T >

Derived from unary_op, this struct checks a property of a single operand, using the predicate defined by the tag Predicate_T, and reports the symbol of the tag followed by the operand upon failure, as not_op reports not.

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

• a static constexpr const char* symbol, written before the operand in the failure reports, with the trailing space (for example "even ");
• a static apply (operand) member function template, which receives the unwrapped operand (the value of a to_* wrapper or of a literal) and returns the result as bool.

The tag is passed as an empty constructor argument, so that both template arguments are deduced, for example predicate_op{ value, even{} }.

A temporary is moved into the predicate, and a named operand is copied (see stored_operand_t), so a predicate built in a function from its const& parameter can be returned from it.

Template Parameters

T	The type of the stored operand, either the operand type, or a const reference to it.
Predicate_T	The tag that defines the predicate. It is stateless, with a static symbol and a static apply(); a predicate that needs a parameter is a comparison of two operands (see compare_op).

Definition at line 1252 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

predicate_op()

template<class T, class Predicate_T>
requires extension::predicate_tag<Predicate_T, unwrapped_t<U>>

template<class U>
requires extension::predicate_tag<Predicate_T, unwrapped_t<U>>

micro_os_plus::micro_test_plus::detail::predicate_op< T, Predicate_T >::predicate_op ( U && t, Predicate_T  )

constexpr

The result is computed from the argument, before it is forwarded to the base. The tag argument is used only to deduce Predicate_T.

Template Parameters

U	The type of the operand argument.

Parameters

t	The operand.

Applies the predicate of the tag to the unwrapped operand, and passes the boolean result, with the operand prepared by as_operand(), to the unary_op base class constructor.

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

        : unary_op<T>{ detail::as_operand (std::forward<U> (t)),
                       static_cast<bool> (
                           Predicate_T::apply (detail::unwrap (t))) }
    {

Member Function Documentation

operand()

template<class T>

decltype(auto) constexpr micro_os_plus::micro_test_plus::detail::unary_op< T >::operand ( 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 operand value.

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

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

    {
      return detail::unwrap (t_);
    }

References operand(), t_, and micro_os_plus::micro_test_plus::detail::unwrap().

Referenced by operand().

operator bool()

template<class T>

micro_os_plus::micro_test_plus::detail::unary_op< T >::operator bool ( ) const

nodiscardconstexprinherited

Parameters

None.

Returns

The result of the operation.

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

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

    {
      return value_;
    }

References unary_op(), and value_.

Member Data Documentation

t_

template<class T>

T micro_os_plus::micro_test_plus::detail::unary_op< T >::t_

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 309 of file detail.h.

Referenced by unary_op(), and operand().

value_

template<class T>

const bool micro_os_plus::micro_test_plus::detail::unary_op< T >::value_ {}

privateinherited

Computed once, by the derived comparator constructor.

Definition at line 317 of file detail.h.

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

---

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

• detail.h
• detail-inlines.h