Blaze 3.9
Loading...
Searching...
No Matches
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TAG(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TAG(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COPY_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MOVE_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_BASE_OF(B, D)
 Constraint on the inheritance relationship.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF(B, D)
 Constraint on the inheritance relationship.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF(B, D)
 Constraint on the inheritance relationship.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF(B, D)
 Constraint on the inheritance relationship.
#define BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CHARACTER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CHARACTER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE(P1, P2)
 Constraint on the pointer relationship.
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_DOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_DOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_FLOAT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_FLOAT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CONST(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COPY_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MOVE_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE(FROM, TO)
 Constraint on the pointer relationship.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE(FROM, TO)
 Constraint on the pointer relationship.
#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM(D, B)
 Constraint on the inheritance relationship of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM(D, B)
 Constraint on the inheritance relationship of a data type.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM(D, B)
 Constraint on the inheritance relationship of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM(D, B)
 Constraint on the inheritance relationship of a data type.
#define BLAZE_CONSTRAINT_MUST_BE_DESTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DESTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DESTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DESTRUCTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_EMPTY(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ENUM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ENUM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_GREATER_THAN_COMPARISON(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_GREATER_THAN_COMPARISON(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_INTEGER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_LESS_THAN_COMPARISON(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_LESS_THAN_COMPARISON(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_LONG_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONG_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_LVALUE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LVALUE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_POD(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POD(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_RANK(T, N)
 Constraint on the rank of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK(T, N)
 Constraint on the rank of a data type.
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_RVALUE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RVALUE_REFERENCE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE(T1, T2)
 Constraint on the size of two data types.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE(T1, T2)
 Constraint on the size of two data types.
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE(A, B)
 Data type constraint.
#define BLAZE_CONSTRAINT_MUST_BE_SHORT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHORT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_SIZE(T, S)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE(T, S)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES(T)
 Constraint on the size of a data type.
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION(T, TYPELIST)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_TYPE_RESTRICTION(T, TYPELIST)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNION(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNION(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VALID_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VALID_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VOID(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOID(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VOLATILE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
 Constraint on the data type.

Detailed Description

Compile time constraints offer the possibility to stop the compilation process if a constraint that can be checked at compile time is not met. These constraints are especially useful for generic code, where the type of the involved objects is not known beforehands.
Since C++11 the C++ standard provides the static_assert functionality to check compile time constant expressions:

template <class T>
class RotationMatrix
{
// ...
static_assert( std::is_floating_point_v<T>, "Non-floating point type detected" );
// ...
};

The Blaze library extends this functionality in the form of compile time constraint macros:

template <class T>
class RotationMatrix
{
// ...
// ...
};
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)
Constraint on the data type.
Definition FloatingPoint.h:61

The compile time constraints provided by the Blaze library built on static_assert, but offer the additional advantages ...

  • ... of a more convenient and easier usage since details are abstracted;
  • ... of a more obvious and more explicit way to express compile time constraints;
  • ... of encapsulation of complex compile time conditions.

The following example demonstrates the BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM time constraint and shows a possible error message:

//----- Test.cpp -----
#include <blaze/Util.h>
class A {};
class B : public A {};
class C {};
int main()
{
BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM( B, A ); // No compile time error, B is derived from A
BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM( C, A ); // Compile time error, C is not derived from A
}
Header file for the inclusion of the utility module of the Blaze library.
#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM(D, B)
Constraint on the inheritance relationship of a data type.
Definition DerivedFrom.h:60

The resulting error message generated by the GNU g++ compiler contains the name of the constraint, a descriptive error message and the source code line of the constraint violation:

~/blaze/blaze/util/constraints/DerivedFrom.h:61:4: static assertion failed: Broken inheritance hierarchy detected
static_assert( ::blaze::IsBaseOf_v<B,D>, "Broken inheritance hierarchy detected" )
^
Test.cpp:11:4: note: in expansion of macro 'BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM'
BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM( C, A ); // Compile time error, C is not derived from A
constexpr bool IsBaseOf_v
Auxiliary variable template for the IsBaseOf type trait.
Definition IsBaseOf.h:100

Macro Definition Documentation

◆ BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE ( T)
Value:
static_assert( ::blaze::IsArithmetic_v<T>, "Non-arithmetic type detected" )
constexpr bool IsArithmetic_v
Auxiliary variable template for the IsArithmetic type trait.
Definition IsArithmetic.h:98

Constraint on the data type.

In case the given data type T is not an arithmetic data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE ( T)
Value:
static_assert( ::blaze::IsArray_v<T>, "Non-array type detected" )
constexpr bool IsArray_v
Auxiliary variable template for the IsArray type trait.
Definition IsArray.h:95

Constraint on the data type.

In case the given data type T is no array type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_BASE_OF

#define BLAZE_CONSTRAINT_MUST_BE_BASE_OF ( B,
D )
Value:
static_assert( ::blaze::IsBaseOf_v<B,D>, "Broken inheritance relationship detected" )

Constraint on the inheritance relationship.

In case B is not a base class of D, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE ( T)
Value:
static_assert( ::blaze::IsBoolean_v<T>, "Non-boolean type detected" )
constexpr bool IsBoolean_v
Auxiliary variable template for the IsBoolean type trait.
Definition IsBoolean.h:138

Constraint on the data type.

In case the given data type T is not a boolean, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE ( T)
Value:
static_assert( ::blaze::IsBuiltin_v<T>, "Non-built-in type detected" )
constexpr bool IsBuiltin_v
Auxiliary variable template for the IsBuiltin type trait.
Definition IsBuiltin.h:95

Constraint on the data type.

In case the given data type T is not a built-in data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_CHARACTER_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_CHARACTER_TYPE ( T)
Value:
static_assert( ::blaze::IsCharacter_v<T>, "Non-character type detected" )
constexpr bool IsCharacter_v
Auxiliary variable template for the IsCharacter type trait.
Definition IsCharacter.h:172

Constraint on the data type.

In case the given data type T is not a character data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE ( T)
Value:
static_assert( ::blaze::IsClass_v<T>, "Non-class type detected" )
constexpr bool IsClass_v
Auxiliary variable template for the IsClass type trait.
Definition IsClass.h:97

Constraint on the data type.

In case the given data type T is not a user-defined, non-built-in class type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COMPLEX_DOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_DOUBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsComplexDouble_v<T>, "Non-double precision complex type detected" )
constexpr bool IsComplexDouble_v
Auxiliary variable template for the IsComplexDouble type trait.
Definition IsComplexDouble.h:139

Constraint on the data type.

This compile time constraint checks that the given data type T is a double precision complex data type (i.e. complex<double>, ignoring the cv-qualifiers). In case T is not of type complex<double> a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COMPLEX_FLOAT_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_FLOAT_TYPE ( T)
Value:
static_assert( ::blaze::IsComplexFloat_v<T>, "Non-single precision complex type detected" )
constexpr bool IsComplexFloat_v
Auxiliary variable template for the IsComplexFloat type trait.
Definition IsComplexFloat.h:139

Constraint on the data type.

This compile time constraint checks that the given data type T is a single precision complex data type (i.e. complex<float>, ignoring the cv-qualifiers). In case T is not of type complex<float> a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE ( T)
Value:
static_assert( ::blaze::IsComplex_v<T>, "Non-complex type detected" )
constexpr bool IsComplex_v
Auxiliary variable template for the IsComplex type trait.
Definition IsComplex.h:139

Constraint on the data type.

This compile time constraint checks that the given data type T is a complex data type (i.e. an instantiation of complex, ignoring the cv-qualifiers). In case T is not a complex data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_CONST

#define BLAZE_CONSTRAINT_MUST_BE_CONST ( T)
Value:
static_assert( ::blaze::IsConst_v<T>, "Non-const-qualified type detected" )
constexpr bool IsConst_v
Auxiliary variable template for the IsConst type trait.
Definition IsConst.h:95

Constraint on the data type.

In case the given data type is not a const-qualified type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE

#define BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE ( FROM,
TO )
Value:
static_assert( ::blaze::IsConvertible_v<FROM,TO>, "Inconvertible type detected" )
constexpr bool IsConvertible_v
Auxiliary variable template for the IsConvertible type trait.
Definition IsConvertible.h:107

Constraint on the pointer relationship.

In case FROM is not convertible to TO, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COPY_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_COPY_ASSIGNABLE_TYPE ( T)
Value:
static_assert( ::blaze::IsCopyAssignable_v<T>, "Non-copy assignable type detected" )
constexpr bool IsCopyAssignable_v
Auxiliary variable template for the IsCopyAssignable type trait.
Definition IsAssignable.h:188

Constraint on the data type.

In case the given data type T does not provide a copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COPY_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_COPY_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsCopyConstructible_v<T>, "Non-copy constructible type detected" )
constexpr bool IsCopyConstructible_v
Auxiliary variable template for the IsCopyConstructible type trait.
Definition IsConstructible.h:283

Constraint on the data type.

In case the given data type T does not provide a copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DEFAULT_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DEFAULT_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsDefaultConstructible_v<T>, "Non-default constructible type detected" )
constexpr bool IsDefaultConstructible_v
Auxiliary variable template for the IsDefaultConstructible type trait.
Definition IsConstructible.h:187

Constraint on the data type.

In case the given data type T does not provide a default constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM

#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM ( D,
B )
Value:
static_assert( ( ::blaze::IsBaseOf_v<B,D> ), "Broken inheritance relationship detected" )

Constraint on the inheritance relationship of a data type.

In case D is not derived from B, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DESTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DESTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsDestructible_v<T>, "Non-destructible type detected" )
constexpr bool IsDestructible_v
Auxiliary variable template for the IsDestructible type trait.
Definition IsDestructible.h:92

Constraint on the data type.

In case the given data type T cannot be destroyed via its destructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsDouble_v<T>, "Non-double type detected" )
constexpr bool IsDouble_v
Auxiliary variable template for the IsDouble type trait.
Definition IsDouble.h:138

Constraint on the data type.

This compile time constraint checks that the given data type T is of type double (ignoring the cv-qualifiers). In case T is not of type double, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_EMPTY

#define BLAZE_CONSTRAINT_MUST_BE_EMPTY ( T)
Value:
static_assert( ::blaze::IsEmpty_v<T>, "Non-empty type detected" )
constexpr bool IsEmpty_v
Auxiliary variable template for the IsEmpty type trait.
Definition IsEmpty.h:98

Constraint on the data type.

In case the given data type is not an empty type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_ENUM_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_ENUM_TYPE ( T)
Value:
static_assert( ::blaze::IsEnum_v<T>, "Non-enum type detected" )
constexpr bool IsEnum_v
Auxiliary variable template for the IsEnum type trait.
Definition IsEnum.h:100

Constraint on the data type.

In case the given data type T is not an enumeration type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( T)
Value:
static_assert( ::blaze::IsFloat_v<T>, "Non-float type detected" )
constexpr bool IsFloat_v
Auxiliary variable template for the IsFloat type trait.
Definition IsFloat.h:138

Constraint on the data type.

This compile time constraint checks that the given data type T is of type float (ignoring the cv-qualifiers). In case T is not of type float, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE ( T)
Value:
static_assert( ::blaze::IsFloatingPoint_v<T>, "Non-floating point type detected" )
constexpr bool IsFloatingPoint_v
Auxiliary variable template for the IsFloatingPoint type trait.
Definition IsFloatingPoint.h:95

Constraint on the data type.

In case the given data type T is not a floating point data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_INTEGER_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_INTEGER_TYPE ( T)
Value:
static_assert( ::blaze::IsInteger_v<T>, "Non-integer type detected" )
constexpr bool IsInteger_v
Auxiliary variable template for the IsInteger type trait.
Definition IsInteger.h:187

Constraint on the data type.

This compile time constraint checks that the given data type T is of type int (ignoring the cv-qualifiers). In case T is not of type int, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE ( T)
Value:
static_assert( ::blaze::IsIntegral_v<T>, "Non-integral type detected" )
constexpr bool IsIntegral_v
Auxiliary variable template for the IsIntegral type trait.
Definition IsIntegral.h:95

Constraint on the data type.

In case the given data type T is not an integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_LONG_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_LONG_TYPE ( T)
Value:
static_assert( ::blaze::IsLong_v<T>, "Non-long type detected" )
constexpr bool IsLong_v
Auxiliary variable template for the IsLong type trait.
Definition IsLong.h:183

Constraint on the data type.

This compile time constraint checks that the given data type T is a long data type (ignoring the cv-qualifiers). In case T is not a long data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsLongDouble_v<T>, "Non-long double type detected" )
constexpr bool IsLongDouble_v
Auxiliary variable template for the IsLongDouble type trait.
Definition IsLongDouble.h:138

Constraint on the data type.

This compile time constraint checks that the given data type T is of type long double (ignoring the cv-qualifiers). In case T is not of type long double, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_LVALUE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_LVALUE_REFERENCE_TYPE ( T)
Value:
static_assert( ::blaze::IsLValueReference_v<T>, "Non-lvalue reference type detected" )
constexpr bool IsLValueReference_v
Auxiliary variable template for the IsLValueReference type trait.
Definition IsLValueReference.h:96

Constraint on the data type.

In case the given data type T is not an lvalue reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MOVE_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MOVE_ASSIGNABLE_TYPE ( T)
Value:
static_assert( ::blaze::IsMoveAssignable_v<T>, "Non-move assignable type detected" )
constexpr bool IsMoveAssignable_v
Auxiliary variable template for the IsMoveAssignable type trait.
Definition IsAssignable.h:285

Constraint on the data type.

In case the given data type T does not provide a move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MOVE_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MOVE_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsMoveConstructible_v<T>, "Non-move constructible type detected" )
constexpr bool IsMoveConstructible_v
Auxiliary variable template for the IsMoveConstructible type trait.
Definition IsConstructible.h:379

Constraint on the data type.

In case the given data type T does not provide a move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_ASSIGNABLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowCopyAssignable_v<T>, "Non-noexcept copy assignable type detected" )
constexpr bool IsNothrowCopyAssignable_v
Auxiliary variable template for the IsNothrowCopyAssignable type trait.
Definition IsAssignable.h:237

Constraint on the data type.

In case the given data type T does not provide a noexcept copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowCopyConstructible_v<T>, "Non-noexcept copy constructible type detected" )
constexpr bool IsNothrowCopyConstructible_v
Auxiliary variable template for the IsNothrowCopyConstructible type trait.
Definition IsConstructible.h:331

Constraint on the data type.

In case the given data type T does not provide a noexcept copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowDefaultConstructible_v<T>, "Non-noexcept default constructible type detected" )
constexpr bool IsNothrowDefaultConstructible_v
Auxiliary variable template for the IsNothrowDefaultConstructible type trait.
Definition IsConstructible.h:235

Constraint on the data type.

In case the given data type T does not provide a noexcept default constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DESTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DESTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowDestructible_v<T>, "Non-noexcept destructible type detected" )
constexpr bool IsNothrowDestructible_v
Auxiliary variable template for the IsNothrowDestructible type trait.
Definition IsDestructible.h:141

Constraint on the data type.

In case the given data type T cannot be destroyed via a noexcept destructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowMoveAssignable_v<T>, "Non-noexcept move assignable type detected" )
constexpr bool IsNothrowMoveAssignable_v
Auxiliary variable template for the IsNothrowMoveAssignable type trait.
Definition IsAssignable.h:334

Constraint on the data type.

In case the given data type T does not provide a noexcept move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( ::blaze::IsNothrowMoveConstructible_v<T>, "Non-noexcept move constructible type detected" )
constexpr bool IsNothrowMoveConstructible_v
Auxiliary variable template for the IsNothrowMoveConstructible type trait.
Definition IsConstructible.h:427

Constraint on the data type.

In case the given data type T does not provide a noexcept move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE ( T)
Value:
static_assert( ::blaze::IsNumeric_v<T>, "Non-numeric type detected" )
constexpr bool IsNumeric_v
Auxiliary variable template for the IsNumeric type trait.
Definition IsNumeric.h:132

Constraint on the data type.

In case the given data type T is not a numeric (integral or floating point) data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE ( T)
Value:
static_assert( ::blaze::IsObject_v<T>, "Non-object type detected" )
constexpr bool IsObject_v
Auxiliary variable template for the IsObject type trait.
Definition IsObject.h:96

Constraint on the data type.

In case the given data type T is not an object type (i.e., everything except references, void, and function types), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_POD

#define BLAZE_CONSTRAINT_MUST_BE_POD ( T)
Value:
static_assert( ::blaze::IsPod_v<T>, "Non-POD type detected" )
constexpr bool IsPod_v
Auxiliary variable template for the IsPod type trait.
Definition IsPod.h:107

Constraint on the data type.

In case the given data type is not a POD type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE ( T)
Value:
static_assert( ::blaze::IsPointer_v<T>, "Non-pointer type detected" )
constexpr bool IsPointer_v
Auxiliary variable template for the IsPointer type trait.
Definition IsPointer.h:95

Constraint on the data type.

In case the given data type T is not a pointer type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE ( T)
Value:
static_assert( ::blaze::IsReference_v<T>, "Non-reference type detected" )
constexpr bool IsReference_v
Auxiliary variable template for the IsReference type trait.
Definition IsReference.h:95

Constraint on the data type.

In case the given data type T is not a reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_RVALUE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_RVALUE_REFERENCE_TYPE ( T)
Value:
static_assert( ::blaze::IsRValueReference_v<T>, "Non-rvalue reference type detected" )
constexpr bool IsRValueReference_v
Auxiliary variable template for the IsRValueReference type trait.
Definition IsRValueReference.h:97

Constraint on the data type.

In case the given data type T is not an rvalue reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SAME_TAG

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TAG ( A,
B )
Value:
static_assert( ::blaze::IsSame_v<A,B>, "Non-matching tags detected" )
constexpr bool IsSame_v
Auxiliary variable template for the IsSame type trait.
Definition IsSame.h:159

Data type constraint.

In case the two types A and B are not the same tag (ignoring all cv-qualifiers of both data types), a compilation error is created. The following example illustrates the behavior of this constraint:

BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, double ); // No compilation error
BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, const double ); // No compilation error (only cv-qualifiers differ)
BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, float ); // Compilation error, different data types!
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
Data type constraint.
Definition SameType.h:71

◆ BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE ( A,
B )
Value:
static_assert( ::blaze::IsSame_v<A,B>, "Non-matching types detected" )

Data type constraint.

In case the two types A and B are not the same (ignoring all cv-qualifiers of both data types), a compilation error is created. The following example illustrates the behavior of this constraint:

BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, double ); // No compilation error
BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, const double ); // No compilation error (only cv-qualifiers differ)
BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, float ); // Compilation error, different data types!

In case the cv-qualifiers should not be ignored (e.g. 'double' and 'const double' should be considered to be unequal), use the blaze::BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE constraint.

◆ BLAZE_CONSTRAINT_MUST_BE_SHORT_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SHORT_TYPE ( T)
Value:
static_assert( ::blaze::IsShort_v<T>, "Non-short type detected" )
constexpr bool IsShort_v
Auxiliary variable template for the IsShort type trait.
Definition IsShort.h:183

Constraint on the data type.

This compile time constraint checks that the given data type T is a short data type (ignoring the cv-qualifiers). In case T is not a short data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE ( T)
Value:
static_assert( ::blaze::IsSigned_v<T>, "Non-signed type detected" )
constexpr bool IsSigned_v
Auxiliary variable template for the IsSigned type trait.
Definition IsSigned.h:97

Constraint on the data type.

In case the given data type T is not an signed integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF ( B,
D )
Value:
static_assert( ::blaze::IsBaseOf_v<B,D> && !::blaze::IsBaseOf_v<D,B> , "Broken inheritance relationship detected" )

Constraint on the inheritance relationship.

In case B is not a base class of D, a compilation error is created. In contrast to the BLAZE_CONSTRAINT_MUST_BE_BASE_OF constraint, a compilation error is also created in case B and D are the same type.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM ( D,
B )
Value:
static_assert( ( ::blaze::IsBaseOf_v<B,D> && !::blaze::IsBaseOf_v<D,B> ), "Broken inheritance relationship detected" )

Constraint on the inheritance relationship of a data type.

In case D is not derived from B, a compilation error is created. In contrast to the BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM constraint, a compilation error is also created in case D and B are the same type.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE ( A,
B )
Value:
static_assert( ::blaze::IsStrictlySame_v<A,B>, "Non-matching types detected" )
constexpr bool IsStrictlySame_v
Auxiliary variable template for the IsStrictlySame type trait.
Definition IsSame.h:106

Data type constraint.

In case the two types A and B are not the same, a compilation error is created. Note that this constraint even considers two types as unequal if the cv-qualifiers differ, e.g.

BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, double ); // No compilation error
BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, const double ); // Compilation error, different cv-qualifiers!
BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, float ); // Compilation error, different data types!
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B)
Data type constraint.
Definition SameType.h:131

In case the cv-qualifiers should be ignored (e.g. 'double' and 'const double' should be considered to be equal), use the blaze::BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE constraint.

◆ BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE

#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE ( T)
Value:
static_assert( sizeof( std::declval<T>()[0] ) > 0UL, "Non-subscriptable type detected" )

Constraint on the data type.

In case the given data type is not subscriptable, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER

#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER ( T)
Value:
static_assert( sizeof( 0[std::declval<T>()] ) > 0UL, "Non-subscriptable pointer detected" )

Constraint on the data type.

In case the given data type is not a subscriptable pointer, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_UNION

#define BLAZE_CONSTRAINT_MUST_BE_UNION ( T)
Value:
static_assert( ::blaze::IsUnion_v<T>, "Non-union type detected" )
constexpr bool IsUnion_v
Auxiliary variable template for the IsUnion type trait.
Definition IsUnion.h:98

Constraint on the data type.

In case the given data type is not a union type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE ( T)
Value:
static_assert( ::blaze::IsUnsigned_v<T>, "Non-unsigned type detected" )
constexpr bool IsUnsigned_v
Auxiliary variable template for the IsUnsigned type trait.
Definition IsUnsigned.h:97

Constraint on the data type.

In case the given data type T is not an unsigned integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VALID_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VALID_TYPE ( T)
Value:
static_assert( blaze::IsValid_v<T>, "Invalid type detected" )
constexpr bool IsValid_v
Auxiliary variable template for the IsValid type trait.
Definition IsValid.h:139

Constraint on the data type.

In case the given data type is not a valid type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE ( T)
Value:
static_assert( blaze::IsVectorizable_v<T>, "Non-vectorizable type detected" )
constexpr bool IsVectorizable_v
Auxiliary variable template for the IsVectorizable type trait.
Definition IsVectorizable.h:157

Constraint on the data type.

In case the given data type T is not a vectorizable data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VOID

#define BLAZE_CONSTRAINT_MUST_BE_VOID ( T)
Value:
static_assert( ::blaze::IsVoid_v<T>, "Non-void type detected" )
constexpr bool IsVoid_v
Auxiliary variable template for the IsVoid type trait.
Definition IsVoid.h:95

Constraint on the data type.

In case the given data type is not void, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VOLATILE

#define BLAZE_CONSTRAINT_MUST_BE_VOLATILE ( T)
Value:
static_assert( ::blaze::IsVolatile_v<T>, "Non-volatile-qualified type detected" )
constexpr bool IsVolatile_v
Auxiliary variable template for the IsVolatile type trait.
Definition IsVolatile.h:95

Constraint on the data type.

In case the given data type is not a volatile-qualified type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE

#define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE ( T)
Value:
static_assert( ::blaze::Has1Byte_v<T>, "Invalid size detected" )
constexpr bool Has1Byte_v
Auxiliary variable template for the Has1Byte type trait.
Definition HasSize.h:223

Constraint on the size of a data type.

In case the type T doesn't have a size of exactly 1 byte, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES

#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES ( T)
Value:
static_assert( ::blaze::Has2Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T doesn't have a size of exactly 2 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES

#define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES ( T)
Value:
static_assert( ::blaze::Has4Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T doesn't have a size of exactly 4 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES

#define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES ( T)
Value:
static_assert( ::blaze::Has8Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T doesn't have a size of exactly 8 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_GREATER_THAN_COMPARISON

#define BLAZE_CONSTRAINT_MUST_HAVE_GREATER_THAN_COMPARISON ( T1,
T2 )
Value:
static_assert( ::blaze::HasGreaterThan_v<T1,T2>, "Types without greater-than comparison detected" )
constexpr bool HasGreaterThan_v
Auxiliary variable template for the HasGreaterThan type trait.
Definition HasGreaterThan.h:102

Constraint on the data type.

In case the given data types T1 and T2 cannot be compared in a greater-than comparison a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_LESS_THAN_COMPARISON

#define BLAZE_CONSTRAINT_MUST_HAVE_LESS_THAN_COMPARISON ( T1,
T2 )
Value:
static_assert( ::blaze::HasLessThan_v<T1,T2>, "Types without less-than comparison detected" )
constexpr bool HasLessThan_v
Auxiliary variable template for the HasLessThan type trait.
Definition HasLessThan.h:102

Constraint on the data type.

In case the given data types T1 and T2 cannot be compared in a less-than comparison a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_RANK

#define BLAZE_CONSTRAINT_MUST_HAVE_RANK ( T,
N )
Value:
static_assert( ::blaze::Rank_v<T> == N, "Invalid rank detected" )
constexpr size_t Rank_v
Auxiliary variable template for the Rank type trait.
Definition Rank.h:114

Constraint on the rank of a data type.

In case the type T doesn't have a rank of N, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE

#define BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE ( T1,
T2 )
Value:
static_assert( ::blaze::HaveSameSize_v<T1,T2>, "Non-matching sizes detected" )
constexpr bool HaveSameSize_v
Auxiliary variable template for the HaveSameSize type trait.
Definition HaveSameSize.h:165

Constraint on the size of two data types.

In case the types T1 and T2 don't have the same size, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_SIZE

#define BLAZE_CONSTRAINT_MUST_HAVE_SIZE ( T,
S )
Value:
static_assert( ::blaze::HasSize_v<T,S>, "Invalid size detected" )
constexpr bool HasSize_v
Auxiliary variable template for the HasSize type trait.
Definition HasSize.h:171

Constraint on the size of a data type.

In case the type T doesn't have a size of S bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE ( T)
Value:
static_assert( !::blaze::IsArithmetic_v<T>, "Arithmetic type detected" )

Constraint on the data type.

In case the given data type T is an arithmetic data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE ( T)
Value:
static_assert( !::blaze::IsArray_v<T>, "Array type detected" )

Constraint on the data type.

In case the given data type T is an array type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF ( B,
D )
Value:
static_assert( !::blaze::IsBaseOf_v<B,D>, "Unexpected inheritance relationship detected" )

Constraint on the inheritance relationship.

In case B is a base class of D or in case B is the same type as D, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE ( T)
Value:
static_assert( !::blaze::IsBoolean_v<T>, "Boolean type detected" )

Constraint on the data type.

In case the given data type T is a boolean, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE ( T)
Value:
static_assert( !::blaze::IsBuiltin_v<T>, "Built-in type detected" )

Constraint on the data type.

In case the given data type T is a built-in data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CHARACTER_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CHARACTER_TYPE ( T)
Value:
static_assert( !::blaze::IsCharacter_v<T>, "Character type detected" )

Constraint on the data type.

In case the given data type T is a character data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE ( T)
Value:
static_assert( !::blaze::IsClass_v<T>, "Class type detected" )

Constraint on the data type.

In case the given data type T is a user-defined, non-built-in class type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_DOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_DOUBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsComplexDouble_v<T>, "Double precision complex type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not a double precision complex data type (i.e. complex<double>, ignoring the cv-qualifiers). In case T is of type complex<double> a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_FLOAT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_FLOAT_TYPE ( T)
Value:
static_assert( !::blaze::IsComplexFloat_v<T>, "Single precision complex type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not a single precision complex data type (i.e. complex<float>, ignoring the cv-qualifiers). In case T is of type complex<float> a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE ( T)
Value:
static_assert( !::blaze::IsComplex_v<T>, "Complex type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not a complex data type (i.e. an instantiation of complex, ignoring the cv-qualifiers). In case T is a complex data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CONST

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST ( T)
Value:
static_assert( !::blaze::IsConst_v<T>, "Const-qualified type detected" )

Constraint on the data type.

In case the given data type is a const-qualified type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE ( FROM,
TO )
Value:
static_assert( !::blaze::IsConvertible_v<FROM,TO>, "Convertible type detected" )

Constraint on the pointer relationship.

In case FROM is convertible to TO, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_ASSIGNABLE_TYPE ( T)
Value:
static_assert( !::blaze::IsCopyAssignable_v<T>, "Copy assignable type detected" )

Constraint on the data type.

In case the given data type T does provide a copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsCopyConstructible_v<T>, "Copy constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DEFAULT_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DEFAULT_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsDefaultConstructible_v<T>, "Default constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a default constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM ( D,
B )
Value:
static_assert( ( !::blaze::IsBaseOf_v<B,D> ), "Unexpected inheritance relationship detected" )

Constraint on the inheritance relationship of a data type.

In case D is derived from B or in case D is the same type as B, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DESTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DESTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsDestructible_v<T>, "Destructible type detected" )

Constraint on the data type.

In case the given data type T can be destroyed via its destructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsDouble_v<T>, "Double type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not of type double (ignoring the cv-qualifiers). In case T is of type double, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY

#define BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY ( T)
Value:
static_assert( !::blaze::IsEmpty_v<T>, "Empty type detected" )

Constraint on the data type.

In case the given data type is an empty type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ENUM_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_ENUM_TYPE ( T)
Value:
static_assert( !::blaze::IsEnum_v<T>, "Enum type detected" )

Constraint on the data type.

In case the given data type T is an enumeration type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE ( T)
Value:
static_assert( !::blaze::IsFloat_v<T>, "Float type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not of type float (ignoring the cv-qualifiers). In case T is of type float, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE ( T)
Value:
static_assert( !::blaze::IsFloatingPoint_v<T>, "Floating point type detected" )

Constraint on the data type.

In case the given data type T is a floating point data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGER_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGER_TYPE ( T)
Value:
static_assert( !::blaze::IsInteger_v<T>, "Integer type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not of type int (ignoring the cv-qualifiers). In case T is of type int, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE ( T)
Value:
static_assert( !::blaze::IsIntegral_v<T>, "Integral type detected" )

Constraint on the data type.

In case the given data type T is an integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_LONG_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONG_TYPE ( T)
Value:
static_assert( !::blaze::IsLong_v<T>, "Long type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not a long data type (ignoring the cv-qualifiers). In case T is a long data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsLongDouble_v<T>, "Long double type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not of type long double (ignoring the cv-qualifiers). In case T is of type long double, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_LVALUE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_LVALUE_REFERENCE_TYPE ( T)
Value:
static_assert( !::blaze::IsLValueReference_v<T>, "Lvalue reference type detected" )

Constraint on the data type.

In case the given data type T is not an lvalue reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_ASSIGNABLE_TYPE ( T)
Value:
static_assert( !::blaze::IsMoveAssignable_v<T>, "Move assignable type detected" )

Constraint on the data type.

In case the given data type T does provide a move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsMoveConstructible_v<T>, "Move constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_ASSIGNABLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowCopyAssignable_v<T>, "Noexcept copy assignable type detected" )

Constraint on the data type.

In case the given data type T does provide a noexcept copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowCopyConstructible_v<T>, "Noexcept copy constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a noexcept copy constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowDefaultConstructible_v<T>, "Noexcept default constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a noexcept default constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DESTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DESTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowDestructible_v<T>, "Noexcept destructible type detected" )

Constraint on the data type.

In case the given data type T can be destroyed via a noexcept destructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowMoveAssignable_v<T>, "Noexcept move assignable type detected" )

Constraint on the data type.

In case the given data type T does provide a noexcept move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE ( T)
Value:
static_assert( !::blaze::IsNothrowMoveConstructible_v<T>, "Noexcept move constructible type detected" )

Constraint on the data type.

In case the given data type T does provide a noexcept move constructor, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE ( T)
Value:
static_assert( !::blaze::IsNumeric_v<T>, "Numeric type detected" )

Constraint on the data type.

In case the given data type T is a numeric (integral or floating point) data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE ( T)
Value:
static_assert( !::blaze::IsObject_v<T>, "Object type detected" )

Constraint on the data type.

In case the given data type T is not a object type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_POD

#define BLAZE_CONSTRAINT_MUST_NOT_BE_POD ( T)
Value:
static_assert( !::blaze::IsPod_v<T>, "POD type detected" )

Constraint on the data type.

In case the given data type is a POD type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE ( T)
Value:
static_assert( !::blaze::IsPointer_v<T>, "Pointer type detected" )

Constraint on the data type.

In case the given data type T is not a pointer type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE ( T)
Value:
static_assert( !::blaze::IsReference_v<T>, "Reference type detected" )

Constraint on the data type.

In case the given data type T is not a reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_RVALUE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_RVALUE_REFERENCE_TYPE ( T)
Value:
static_assert( !::blaze::IsRValueReference_v<T>, "Rvalue reference type detected" )

Constraint on the data type.

In case the given data type T is not an rvalue reference type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TAG

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TAG ( A,
B )
Value:
static_assert( !::blaze::IsSame_v<A,B>, "Matching tags detected" )

Data type constraint.

In case the two types A and B are the same tag (ignoring all cv-qualifiers of both data types), a compilation error is created. The following example illustrates the behavior of this constraint:

BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, float ); // No compilation error, different data types
BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, const double ); // Compilation error (only cv-qualifiers differ)
BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, double ); // Compilation error, same data type!
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE(A, B)
Data type constraint.
Definition SameType.h:102

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE ( A,
B )
Value:
static_assert( !::blaze::IsSame_v<A,B>, "Matching types detected" )

Data type constraint.

In case the two types A and B are the same (ignoring all cv-qualifiers of both data types), a compilation error is created. The following example illustrates the behavior of this constraint:

BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, float ); // No compilation error, different data types
BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, const double ); // Compilation error (only cv-qualifiers differ)
BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, double ); // Compilation error, same data type!

In case the cv-qualifiers should not be ignored (e.g. 'double' and 'const double' should be considered to be unequal), use the blaze::BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE constraint.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SHORT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHORT_TYPE ( T)
Value:
static_assert( !::blaze::IsShort_v<T>, "Short type detected" )

Constraint on the data type.

This compile time constraint checks that the given data type T is not a short data type (ignoring the cv-qualifiers). In case T is a short data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE ( T)
Value:
static_assert( !::blaze::IsSigned_v<T>, "Signed type detected" )

Constraint on the data type.

In case the given data type T is an signed integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF ( B,
D )
Value:
static_assert( !::blaze::IsBaseOf_v<B,D> || ::blaze::IsBaseOf_v<D,B> , "Unexpected inheritance relationship detected" )

Constraint on the inheritance relationship.

In case B is a base class of D, a compilation error is created. In contrast to the BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF constraint, no compilation error is created in case B and D are the same type.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM ( D,
B )
Value:
static_assert( ( !::blaze::IsBaseOf_v<B,D> || ::blaze::IsBaseOf_v<D,B> ), "Unexpected inheritance relationship detected" )

Constraint on the inheritance relationship of a data type.

In case D is derived from B, a compilation error is created. In contrast to the BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM constraint, no compilation error is created in case D and B are the same type.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE ( A,
B )
Value:
static_assert( !::blaze::IsStrictlySame_v<A,B>, "Matching types detected" )

Data type constraint.

In case the two types A and B are the same, a compilation error is created. Note that this constraint even considers two types as unequal if the cv-qualifiers differ, e.g.

BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, float ); // No compilation error, different data types
BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, const double ); // No compilation error, different cv-qualifiers!
BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, double ); // Compilation error, same data type!
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE(A, B)
Data type constraint.
Definition SameType.h:160

In case the cv-qualifiers should be ignored (e.g. 'double' and 'const double' should be considered to be equal), use the blaze::BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE constraint.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNION

#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNION ( T)
Value:
static_assert( !::blaze::IsUnion_v<T>, "Union type detected" )

Constraint on the data type.

In case the given data type is a union type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE ( T)
Value:
static_assert( !::blaze::IsUnsigned_v<T>, "Unsigned type detected" )

Constraint on the data type.

In case the given data type T is an unsigned integral data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VALID_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VALID_TYPE ( T)
Value:
static_assert( !blaze::IsValid_v<T>, "Valid type detected" )

Constraint on the data type.

In case the given data type is a valid type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE ( T)
Value:
static_assert( !blaze::IsVectorizable_v<T>, "Vectorizable type detected" )

Constraint on the data type.

In case the given data type T is a vectorizable data type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VOID

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOID ( T)
Value:
static_assert( !::blaze::IsVoid_v<T>, "Void type detected" )

Constraint on the data type.

In case the given data type is void, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE ( T)
Value:
static_assert( !::blaze::IsVolatile_v<T>, "Volatile-qualified type detected" )

Constraint on the data type.

In case the given data type is a volatile-qualified type, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE ( T)
Value:
static_assert( !::blaze::Has1Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T has a size of exactly 1 byte, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES ( T)
Value:
static_assert( !::blaze::Has2Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T has a size of exactly 2 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES ( T)
Value:
static_assert( !::blaze::Has4Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T has a size of exactly 4 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES ( T)
Value:
static_assert( !::blaze::Has8Byte_v<T>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T has a size of exactly 8 bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_GREATER_THAN_COMPARISON

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_GREATER_THAN_COMPARISON ( T1,
T2 )
Value:
static_assert( !::blaze::HasGreaterThan_v<T1,T2>, "Type with greater-than comparison detected" )

Constraint on the data type.

In case the given data types T1 and T2 cannot be compared in a greater-than comparison a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_LESS_THAN_COMPARISON

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_LESS_THAN_COMPARISON ( T1,
T2 )
Value:
static_assert( !::blaze::HasLessThan_v<T1,T2>, "Type with less-than comparison detected" )

Constraint on the data type.

In case the given data types T1 and T2 cannot be compared in a less-than comparison a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK ( T,
N )
Value:
static_assert( ::blaze::Rank_v<T> != N, "Invalid rank detected" )

Constraint on the rank of a data type.

In case the type T has a rank of N, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE ( T1,
T2 )
Value:
static_assert( !::blaze::HaveSameSize_v<T1,T2>, "Matching sizes detected" )

Constraint on the size of two data types.

In case the types T1 and T2 have the same size, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE ( T,
S )
Value:
static_assert( !::blaze::HasSize_v<T,S>, "Invalid size detected" )

Constraint on the size of a data type.

In case the type T has a size of S bytes, a compilation error is created.

◆ BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE

#define BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE ( P1,
P2 )
Value:
static_assert( ::blaze::IsConvertible_v<P1,P2> || ::blaze::IsConvertible_v<P2,P1>, "Incomparable pointer types detected" );

Constraint on the pointer relationship.

In case P1 is not comparable with P2, a compilation error is created.

◆ BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION

#define BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION ( T,
TYPELIST )
Value:
static_assert( ::blaze::ContainsRelated<TYPELIST,T>::value, "Unapproved type detected" )
Searching a type list.
Definition ContainsRelated.h:90

Constraint on the data type.

In case the given type list TYPELIST does not contain a type related to T, a compilation error is created.

◆ BLAZE_CONSTRAINT_TYPE_RESTRICTION

#define BLAZE_CONSTRAINT_TYPE_RESTRICTION ( T,
TYPELIST )
Value:
static_assert( ::blaze::Contains<TYPELIST,T>::value, "Unapproved type detected" )
Searching a type list.
Definition Contains.h:77

Constraint on the data type.

In case the given type list TYPELIST does not contain the data type T, a compilation error is created.