Macros
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE(T)
 Constraint on the data type.In case the given data type T is not an arithmetic data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE(T)
 Constraint on the data type.In case the given data type T is an arithmetic data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE(T)
 Constraint on the data type.In case the given data type T is no array type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE(T)
 Constraint on the data type.In case the given data type T is an array type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BASE_OF(B, D)
 Constraint on the inheritance relationship.In case B is not a base class of D, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF(B, D)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF(B, D)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF(B, D)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE(T)
 Constraint on the data type.In case the given data type T is not a boolean, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE(T)
 Constraint on the data type.In case the given data type T is a boolean, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE(T)
 Constraint on the data type.In case the given data type T is not a built-in data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE(T)
 Constraint on the data type.In case the given data type T is a built-in data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE(P1, P2)
 Constraint on the pointer relationship.In case P1 is not comparable with P2, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CONST(T)
 Constraint on the data type.In case the given data type is not a const-qualified type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
 Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE(FROM, TO)
 Constraint on the pointer relationship.In case FROM is not convertible to TO, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE(FROM, TO)
 Constraint on the pointer relationship.In case FROM is convertible to TO, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM(D, B)
 Constraint on the inheritance relationship of a data type.In case D is not derived from B, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM(D, B)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM(D, B)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM(D, B)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EMPTY(T)
 Constraint on the data type.In case the given data type is not an empty type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY(T)
 Constraint on the data type.In case the given data type is an empty type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)
 Constraint on the data type.In case the given data type T is not a floating point data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE(T)
 Constraint on the data type.In case the given data type T is a floating point data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE(T)
 Constraint on the data type.In case the given data type T is not an integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE(T)
 Constraint on the data type.In case the given data type T is an integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE(T)
 Constraint on the data type.In case the given data type T is not a object type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_POD(T)
 Constraint on the data type.In case the given data type is not a POD type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POD(T)
 Constraint on the data type.In case the given data type is a POD type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE(T)
 Constraint on the data type.In case the given data type T is not a pointer type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
 Constraint on the data type.In case the given data type T is not a pointer type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_RANK(T, N)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK(T, N)
 Constraint on the rank of a data type.In case the type T has a rank of N, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
 Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
 Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE(T1, T2)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE(T1, T2)
 Constraint on the size of two data types.In case the types T1 and T2 have the same size, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
 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: More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE(A, B)
 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: More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE(A, B)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE(T)
 Constraint on the data type.In case the given data type T is not an signed integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE(T)
 Constraint on the data type.In case the given data type T is an signed integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_SIZE(T, S)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE(T, S)
 Constraint on the size of a data type.In case the type T has a size of S bytes, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES(T)
 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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE(T)
 Constraint on the data type.In case the given data type is not subscriptable, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(T)
 Constraint on the data type.In case the given data type is not a subscriptable pointer, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION(T, TYPELIST)
 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. More...
 
#define BLAZE_CONSTRAINT_TYPE_RESTRICTION(T, TYPELIST)
 Constraint on the data type.In case the given type list TYPELIST does not contain the data type T, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNION(T)
 Constraint on the data type.In case the given data type is not a union type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNION(T)
 Constraint on the data type.In case the given data type is a union type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE(T)
 Constraint on the data type.In case the given data type T is not an unsigned integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE(T)
 Constraint on the data type.In case the given data type T is an unsigned integral data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)
 Constraint on the data type.In case the given data type T is not a vectorizable data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE(T)
 Constraint on the data type.In case the given data type T is a vectorizable data type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VOID(T)
 Constraint on the data type.In case the given data type is not void, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOID(T)
 Constraint on the data type.In case the given data type is void, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VOLATILE(T)
 Constraint on the data type.In case the given data type is not a volatile-qualified type, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
 Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created. More...
 

Detailed Description

Compile time constraints offer the possibility to stop the compilation 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.
Standard C++ doesn't offer compile time constraints per default. However, most constraints can be rebuilt using the standard language features. The most difficult problem is the error message the compiler generates if a constraint is not met. The compile time constraints implemented in the Blaze library are implemented in such a way that the error message contains the source of the constraint violation as close as possible. The following example demonstrates one of the Blaze compile time constraints and shows two possible error messages for two different compilers:

//----- 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
}

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

Test.cpp: In function 'int main()':
Test.cpp:11: incomplete type ‘blaze::CONSTRAINT_MUST_BE_DERIVED_FROM_FAILED<false>’ used in nested name specifier

The Intel C++-compiler gives the following error message that also contains the name of the violated constraint and the source code line of the violation:

Test.cpp(11): error: incomplete type is not allowed

Macro Definition Documentation

#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_ARITHMETIC_TYPE_FAILED< ::blaze::IsArithmetic<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_ARITHMETIC_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_ARRAY_TYPE_FAILED< ::blaze::IsArray<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_ARRAY_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_BASE_OF (   B,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_BASE_OF_FAILED< ::blaze::IsBaseOf<B,D>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_BASE_OF_TYPEDEF, __LINE__ )

Constraint on the inheritance relationship.In case B is not a base class of D, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_BOOLEAN_TYPE_FAILED< ::blaze::IsBoolean<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_BOOLEAN_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_BUILTIN_TYPE_FAILED< ::blaze::IsBuiltin<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_BUILTIN_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_CLASS_TYPE_FAILED< ::blaze::IsClass<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_CLASS_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_COMPLEX_TYPE_FAILED< ::blaze::IsComplex<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_COMPLEX_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_CONST (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_CONST_FAILED< ::blaze::IsConst<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_CONST_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE (   FROM,
  TO 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_CONVERTIBLE_FAILED< ::blaze::IsConvertible<FROM,TO>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_CONVERTIBLE_TYPEDEF, __LINE__ )

Constraint on the pointer relationship.In case FROM is not convertible to TO, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM (   D,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_DERIVED_FROM_FAILED< ::blaze::IsBaseOf<B,D>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_DERIVED_FROM_TYPEDEF, __LINE__ )

Constraint on the inheritance relationship of a data type.In case D is not derived from B, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_DOUBLE_TYPE_FAILED< ::blaze::IsDouble<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_DOUBLE_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_EMPTY (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_EMPTY_FAILED< ::blaze::IsEmpty<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_EMPTY_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_FLOAT_TYPE_FAILED< ::blaze::IsFloat<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_FLOAT_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE_FAILED< ::blaze::IsFloatingPoint<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_INTEGRAL_TYPE_FAILED< ::blaze::IsIntegral<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_INTEGRAL_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE_FAILED< ::blaze::IsLongDouble<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_NUMERIC_TYPE_FAILED< ::blaze::IsNumeric<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_NUMERIC_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_OBJECT_TYPE_FAILED< ::blaze::IsObject<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_OBJECT_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_BE_POD (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_POD_FAILED< ::blaze::IsPod<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_POD_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_POINTER_TYPE_FAILED< ::blaze::IsPointer<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_POINTER_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_REFERENCE_TYPE_FAILED< ::blaze::IsReference<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_REFERENCE_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE (   A,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_SAME_TYPE_FAILED< ::blaze::IsSame<A,B>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_SAME_TYPE_TYPEDEF, __LINE__ )

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:

1 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, double ); // No compilation error
2 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( double, const double ); // No compilation error (only cv-qualifiers differ)
3 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.

#define BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_SIGNED_TYPE_FAILED< ::blaze::IsSigned<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_SIGNED_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF (   B,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_STRICTLY_BASE_OF_FAILED< ::blaze::IsBaseOf<B,D>::value && \
BLAZE_JOIN( CONSTRAINT_MUST_BE_STRICTLY_BASE_OF_TYPEDEF, __LINE__ )
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relatio...
Definition: IsBaseOf.h:100

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.

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM (   D,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM_FAILED< ::blaze::IsBaseOf<B,D>::value && \
BLAZE_JOIN( CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM_TYPEDEF, __LINE__ )
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relatio...
Definition: IsBaseOf.h:100

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.

#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE (   A,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE_FAILED< ::blaze::IsStrictlySame<A,B>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE_TYPEDEF, __LINE__ )

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.

1 BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, double ); // No compilation error
2 BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, const double ); // Compilation error, different cv-qualifiers!
3 BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE( double, float ); // Compilation error, different data types!

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.

#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_SUBSCRIBTABLE_FAILED< T >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_SUBSCRIPTABLE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_SUBSCRIBTABLE_AS_DECAYABLE_POINTER_FAILED< T >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_SUBSCRIBTABLE_AS_DECAYABLE_POINTER_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_UNION (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_UNION_FAILED< ::blaze::IsUnion<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_UNION_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_UNSIGNED_TYPE_FAILED< ::blaze::IsUnsigned<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_UNSIGNED_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE (   T)
Value:
typedef \
blaze::CONSTRAINT_TEST< \
blaze::CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE_FAILED< blaze::IsVectorizable<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_VOID (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_BE_VOID_FAILED< ::blaze::IsVoid<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_VOID_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_BE_VOLATILE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::laze::CONSTRAINT_MUST_BE_VOLATILE_FAILED< ::blaze::IsVolatile<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_BE_VOLATILE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_1_BYTE_FAILED< ::blaze::Has1Byte<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_1_BYTE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_2_BYTES_FAILED< ::blaze::Has2Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_2_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_4_BYTES_FAILED< ::blaze::Has4Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_4_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_8_BYTES_FAILED< ::blaze::Has8Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_8_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_RANK (   T,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_RANK_FAILED< ::blaze::Rank<T>::value == N >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_RANK_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE (   T1,
  T2 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_SAME_SIZE_FAILED< ::blaze::HaveSameSize<T1,T2>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_SAME_SIZE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_HAVE_SIZE (   T,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_HAVE_SIZE_FAILED< ::blaze::HasSize<T,S>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_HAVE_SIZE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE_FAILED< !::blaze::IsArithmetic<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE_FAILED< !::blaze::IsArray<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF (   B,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_BASE_OF_FAILED< !::blaze::IsBaseOf<B,D>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_BASE_OF_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE_FAILED< !::blaze::IsBoolean<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE_FAILED< !::blaze::IsBuiltin<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_CLASS_TYPE_FAILED< !::blaze::IsClass<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_CLASS_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE_FAILED< !::blaze::IsComplex<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_CONST_FAILED< !::blaze::IsConst<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_CONST_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE (   FROM,
  TO 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_CONVERTIBLE_FAILED< !::blaze::IsConvertible<FROM,TO>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_CONVERTIBLE_TYPEDEF, __LINE__ )

Constraint on the pointer relationship.In case FROM is convertible to TO, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM (   D,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_DERIVED_FROM_FAILED< !::blaze::IsBaseOf<B,D>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_DERIVED_FROM_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE_FAILED< !::blaze::IsDouble<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_EMPTY_FAILED< !::blaze::IsEmpty<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_EMPTY_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE_FAILED< !::blaze::IsFloat<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE_FAILED< !::blaze::IsFloatingPoint<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE_FAILED< !::blaze::IsIntegral<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE_FAILED< !::blaze::IsLongDouble<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE_FAILED< !::blaze::IsNumeric<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE_FAILED< !::blaze::IsObject<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_POD (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_POD_FAILED< !::blaze::IsPod<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_POD_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_POINTER_TYPE_FAILED< !::blaze::IsPointer<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_POINTER_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE_FAILED< !::blaze::IsReference<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE (   A,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_SAME_TYPE_FAILED< !::blaze::IsSame<A,B>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_SAME_TYPE_TYPEDEF, __LINE__ )

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:

1 BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, float ); // No compilation error, different data types
2 BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE( double, const double ); // Compilation error (only cv-qualifiers differ)
3 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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE_FAILED< !::blaze::IsSigned<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF (   B,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF_FAILED< !::blaze::IsBaseOf<B,D>::value || \
BLAZE_JOIN( CONSTRAINT_MUST_NOTBE_STRICTLY_BASE_OF_TYPEDEF, __LINE__ )
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relatio...
Definition: IsBaseOf.h:100

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM (   D,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM_FAILED< !::blaze::IsBaseOf<B,D>::value || \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM_TYPEDEF, __LINE__ )
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relatio...
Definition: IsBaseOf.h:100

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE (   A,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE_FAILED< !::blaze::IsStrictlySame<A,B>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE_TYPEDEF, __LINE__ )

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.

1 BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, float ); // No compilation error, different data types
2 BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, const double ); // No compilation error, different cv-qualifiers!
3 BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE( double, double ); // Compilation error, same data type!

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.

#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNION (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_UNION_FAILED< !::blaze::IsUnion<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_UNION_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE_FAILED< !::blaze::IsUnsigned<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE (   T)
Value:
typedef \
blaze::CONSTRAINT_TEST< \
blaze::CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE_FAILED< !blaze::IsVectorizable<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOID (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_VOID_FAILED< !::blaze::IsVoid<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_VOID_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_BE_VOLATILE_FAILED< !::blaze::IsVolatile<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_BE_VOLATILE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED< !::blaze::Has1Byte<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_1_BYTE_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED< !::blaze::Has2Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_2_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED< !::blaze::Has4Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_4_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES (   T)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED< !::blaze::Has8Bytes<T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_8_BYTES_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK (   T,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_RANK_FAILED< ::blaze::Rank<T>::value != N >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_RANK_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE (   T1,
  T2 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE_FAILED< !::blaze::HaveSameSize<T1,T2>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE_TYPEDEF, __LINE__ )

Constraint on the size of two data types.In case the types T1 and T2 have the same size, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE (   T,
 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED< !::blaze::HasSize<T,S>::value >::value > \
BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_SIZE_TYPEDEF, __LINE__ )

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

#define BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE (   P1,
  P2 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_POINTER_MUST_BE_COMPARABLE_FAILED< ::blaze::IsConvertible<P1,P2>::value || \
BLAZE_JOIN( CONSTRAINT_POINTER_MUST_BE_COMPARABLE_TYPEDEF, __LINE__ )
Compile time pointer relationship constraint.This type traits tests whether the first given template ...
Definition: IsConvertible.h:105

Constraint on the pointer relationship.In case P1 is not comparable with P2, a compilation error is created.

#define BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION (   T,
  TYPELIST 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_SOFT_TYPE_RESTRICTION_FAILED< ::blaze::ContainsRelated<TYPELIST,T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_SOFT_TYPE_RESTRICTION_TYPEDEF, __LINE__ )

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.

#define BLAZE_CONSTRAINT_TYPE_RESTRICTION (   T,
  TYPELIST 
)
Value:
typedef \
::blaze::CONSTRAINT_TEST< \
::blaze::CONSTRAINT_TYPE_RESTRICTION_FAILED< ::blaze::Contains<TYPELIST,T>::value >::value > \
BLAZE_JOIN( CONSTRAINT_TYPE_RESTRICTION_TYPEDEF, __LINE__ )

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