Concept satisfied when a type can be used as a test expression in expect() or require(). More...

#include <extension.h>

Concept definition

    template<class T>
    concept checkable = is_op<T>
                        or (not detail::suspicious_condition<T>
                            and not detail::ambiguous_condition<T>
                            and requires (const T& t) { t ? true : false; })

Detailed Description

Template Parameters

T	The type to be checked.

The checkable concept is satisfied when T is either a framework expression type (see is_op) or a type contextually convertible to bool, as the condition of an if statement is. This includes the types with an explicit operator bool, such as std::optional, std::unique_ptr, std::shared_ptr, and std::function, but not the scoped enumerations, which only a cast converts, nor the types satisfying suspicious_condition (the arrays, the functions, the pointers to functions, to members, and to characters), which would make the check pass by mistake, nor the wrappers of a bool (std::optional<bool>, and the smart pointers to bool), whose condition tests the wrapper, not the bool that it holds. It is used to constrain the expect() and require() function templates, and the operands of all_of(), any_of(), and negate(), ensuring that only sensible expression types are accepted, also when they are wrapped in a logical combinator; an application helper that forwards its argument to them uses it for the same constraint.

The condition of the conditional operator, which cannot be overloaded, is used to test the contextual conversion, applied to a const value, as expect() and require() receive it.

Definition at line 403 of file extension.h.