Blaze 3.9
Macros
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TAG(A, B)    static_assert( ::blaze::IsSame_v<A,B>, "Non-matching tags detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TAG(A, B)    static_assert( !::blaze::IsSame_v<A,B>, "Matching tags detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE(T)    static_assert( ::blaze::IsArithmetic_v<T>, "Non-arithmetic type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARITHMETIC_TYPE(T)    static_assert( !::blaze::IsArithmetic_v<T>, "Arithmetic type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ARRAY_TYPE(T)    static_assert( ::blaze::IsArray_v<T>, "Non-array type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ARRAY_TYPE(T)    static_assert( !::blaze::IsArray_v<T>, "Array type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COPY_ASSIGNABLE_TYPE(T)    static_assert( ::blaze::IsCopyAssignable_v<T>, "Non-copy assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_ASSIGNABLE_TYPE(T)    static_assert( !::blaze::IsCopyAssignable_v<T>, "Copy assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T)    static_assert( ::blaze::IsNothrowCopyAssignable_v<T>, "Non-noexcept copy assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T)    static_assert( !::blaze::IsNothrowCopyAssignable_v<T>, "Noexcept copy assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MOVE_ASSIGNABLE_TYPE(T)    static_assert( ::blaze::IsMoveAssignable_v<T>, "Non-move assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_ASSIGNABLE_TYPE(T)    static_assert( !::blaze::IsMoveAssignable_v<T>, "Move assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T)    static_assert( ::blaze::IsNothrowMoveAssignable_v<T>, "Non-noexcept move assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T)    static_assert( !::blaze::IsNothrowMoveAssignable_v<T>, "Noexcept move assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BASE_OF(B, D)    static_assert( ::blaze::IsBaseOf_v<B,D>, "Broken inheritance relationship detected" )
 Constraint on the inheritance relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BASE_OF(B, D)    static_assert( !::blaze::IsBaseOf_v<B,D>, "Unexpected inheritance relationship detected" )
 Constraint on the inheritance relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_BASE_OF(B, D)    static_assert( ::blaze::IsBaseOf_v<B,D> && !::blaze::IsBaseOf_v<D,B> , "Broken inheritance relationship detected" )
 Constraint on the inheritance relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_BASE_OF(B, D)    static_assert( !::blaze::IsBaseOf_v<B,D> || ::blaze::IsBaseOf_v<D,B> , "Unexpected inheritance relationship detected" )
 Constraint on the inheritance relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BOOLEAN_TYPE(T)    static_assert( ::blaze::IsBoolean_v<T>, "Non-boolean type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BOOLEAN_TYPE(T)    static_assert( !::blaze::IsBoolean_v<T>, "Boolean type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE(T)    static_assert( ::blaze::IsBuiltin_v<T>, "Non-built-in type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BUILTIN_TYPE(T)    static_assert( !::blaze::IsBuiltin_v<T>, "Built-in type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CHARACTER_TYPE(T)    static_assert( ::blaze::IsCharacter_v<T>, "Non-character type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CHARACTER_TYPE(T)    static_assert( !::blaze::IsCharacter_v<T>, "Character type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CLASS_TYPE(T)    static_assert( ::blaze::IsClass_v<T>, "Non-class type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLASS_TYPE(T)    static_assert( !::blaze::IsClass_v<T>, "Class type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_POINTER_MUST_BE_COMPARABLE(P1, P2)    static_assert( ::blaze::IsConvertible_v<P1,P2> || ::blaze::IsConvertible_v<P2,P1>, "Incomparable pointer types detected" );
 Constraint on the pointer relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE(T)    static_assert( ::blaze::IsComplex_v<T>, "Non-complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_TYPE(T)    static_assert( !::blaze::IsComplex_v<T>, "Complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_DOUBLE_TYPE(T)    static_assert( ::blaze::IsComplexDouble_v<T>, "Non-double precision complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_DOUBLE_TYPE(T)    static_assert( !::blaze::IsComplexDouble_v<T>, "Double precision complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_FLOAT_TYPE(T)    static_assert( ::blaze::IsComplexFloat_v<T>, "Non-single precision complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPLEX_FLOAT_TYPE(T)    static_assert( !::blaze::IsComplexFloat_v<T>, "Single precision complex type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CONST(T)    static_assert( ::blaze::IsConst_v<T>, "Non-const-qualified type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)    static_assert( !::blaze::IsConst_v<T>, "Const-qualified type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsDefaultConstructible_v<T>, "Non-default constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsDefaultConstructible_v<T>, "Default constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsNothrowDefaultConstructible_v<T>, "Non-noexcept default constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsNothrowDefaultConstructible_v<T>, "Noexcept default constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COPY_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsCopyConstructible_v<T>, "Non-copy constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COPY_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsCopyConstructible_v<T>, "Copy constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsNothrowCopyConstructible_v<T>, "Non-noexcept copy constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsNothrowCopyConstructible_v<T>, "Noexcept copy constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MOVE_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsMoveConstructible_v<T>, "Non-move constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MOVE_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsMoveConstructible_v<T>, "Move constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsNothrowMoveConstructible_v<T>, "Non-noexcept move constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsNothrowMoveConstructible_v<T>, "Noexcept move constructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CONVERTIBLE(FROM, TO)    static_assert( ::blaze::IsConvertible_v<FROM,TO>, "Inconvertible type detected" )
 Constraint on the pointer relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONVERTIBLE(FROM, TO)    static_assert( !::blaze::IsConvertible_v<FROM,TO>, "Convertible type detected" )
 Constraint on the pointer relationship. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM(D, B)    static_assert( ( ::blaze::IsBaseOf_v<B,D> ), "Broken inheritance relationship detected" )
 Constraint on the inheritance relationship of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DERIVED_FROM(D, B)    static_assert( ( !::blaze::IsBaseOf_v<B,D> ), "Unexpected inheritance relationship detected" )
 Constraint on the inheritance relationship of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_DERIVED_FROM(D, B)    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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_DERIVED_FROM(D, B)    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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DESTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsDestructible_v<T>, "Non-destructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DESTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsDestructible_v<T>, "Destructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOTHROW_DESTRUCTIBLE_TYPE(T)    static_assert( ::blaze::IsNothrowDestructible_v<T>, "Non-noexcept destructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOTHROW_DESTRUCTIBLE_TYPE(T)    static_assert( !::blaze::IsNothrowDestructible_v<T>, "Noexcept destructible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE(T)    static_assert( ::blaze::IsDouble_v<T>, "Non-double type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DOUBLE_TYPE(T)    static_assert( !::blaze::IsDouble_v<T>, "Double type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EMPTY(T)    static_assert( ::blaze::IsEmpty_v<T>, "Non-empty type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EMPTY(T)    static_assert( !::blaze::IsEmpty_v<T>, "Empty type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ENUM_TYPE(T)    static_assert( ::blaze::IsEnum_v<T>, "Non-enum type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ENUM_TYPE(T)    static_assert( !::blaze::IsEnum_v<T>, "Enum type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE(T)    static_assert( ::blaze::IsFloat_v<T>, "Non-float type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOAT_TYPE(T)    static_assert( !::blaze::IsFloat_v<T>, "Float type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)    static_assert( ::blaze::IsFloatingPoint_v<T>, "Non-floating point type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FLOATING_POINT_TYPE(T)    static_assert( !::blaze::IsFloatingPoint_v<T>, "Floating point type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_GREATER_THAN_COMPARISON(T1, T2)    static_assert( ::blaze::HasGreaterThan_v<T1,T2>, "Types without greater-than comparison detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_GREATER_THAN_COMPARISON(T1, T2)    static_assert( !::blaze::HasGreaterThan_v<T1,T2>, "Type with greater-than comparison detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_INTEGER_TYPE(T)    static_assert( ::blaze::IsInteger_v<T>, "Non-integer type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGER_TYPE(T)    static_assert( !::blaze::IsInteger_v<T>, "Integer type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_INTEGRAL_TYPE(T)    static_assert( ::blaze::IsIntegral_v<T>, "Non-integral type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INTEGRAL_TYPE(T)    static_assert( !::blaze::IsIntegral_v<T>, "Integral type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_LESS_THAN_COMPARISON(T1, T2)    static_assert( ::blaze::HasLessThan_v<T1,T2>, "Types without less-than comparison detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_LESS_THAN_COMPARISON(T1, T2)    static_assert( !::blaze::HasLessThan_v<T1,T2>, "Type with less-than comparison detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_LONG_TYPE(T)    static_assert( ::blaze::IsLong_v<T>, "Non-long type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONG_TYPE(T)    static_assert( !::blaze::IsLong_v<T>, "Long type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_LONGDOUBLE_TYPE(T)    static_assert( ::blaze::IsLongDouble_v<T>, "Non-long double type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LONGDOUBLE_TYPE(T)    static_assert( !::blaze::IsLongDouble_v<T>, "Long double type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_LVALUE_REFERENCE_TYPE(T)    static_assert( ::blaze::IsLValueReference_v<T>, "Non-lvalue reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LVALUE_REFERENCE_TYPE(T)    static_assert( !::blaze::IsLValueReference_v<T>, "Lvalue reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)    static_assert( ::blaze::IsNumeric_v<T>, "Non-numeric type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_TYPE(T)    static_assert( !::blaze::IsNumeric_v<T>, "Numeric type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_OBJECT_TYPE(T)    static_assert( ::blaze::IsObject_v<T>, "Non-object type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OBJECT_TYPE(T)    static_assert( !::blaze::IsObject_v<T>, "Object type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_POD(T)    static_assert( ::blaze::IsPod_v<T>, "Non-POD type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POD(T)    static_assert( !::blaze::IsPod_v<T>, "POD type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_POINTER_TYPE(T)    static_assert( ::blaze::IsPointer_v<T>, "Non-pointer type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)    static_assert( !::blaze::IsPointer_v<T>, "Pointer type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_RANK(T, N)    static_assert( ::blaze::Rank_v<T> == N, "Invalid rank detected" )
 Constraint on the rank of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RANK(T, N)    static_assert( ::blaze::Rank_v<T> != N, "Invalid rank detected" )
 Constraint on the rank of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)    static_assert( ::blaze::IsReference_v<T>, "Non-reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)    static_assert( !::blaze::IsReference_v<T>, "Reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_RVALUE_REFERENCE_TYPE(T)    static_assert( ::blaze::IsRValueReference_v<T>, "Non-rvalue reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RVALUE_REFERENCE_TYPE(T)    static_assert( !::blaze::IsRValueReference_v<T>, "Rvalue reference type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_SAME_SIZE(T1, T2)    static_assert( ::blaze::HaveSameSize_v<T1,T2>, "Non-matching sizes detected" )
 Constraint on the size of two data types. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SAME_SIZE(T1, T2)    static_assert( !::blaze::HaveSameSize_v<T1,T2>, "Matching sizes detected" )
 Constraint on the size of two data types. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)    static_assert( ::blaze::IsSame_v<A,B>, "Non-matching types detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE(A, B)    static_assert( !::blaze::IsSame_v<A,B>, "Matching types detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B)    static_assert( ::blaze::IsStrictlySame_v<A,B>, "Non-matching types detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE(A, B)    static_assert( !::blaze::IsStrictlySame_v<A,B>, "Matching types detected" )
 Data type constraint. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SHORT_TYPE(T)    static_assert( ::blaze::IsShort_v<T>, "Non-short type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHORT_TYPE(T)    static_assert( !::blaze::IsShort_v<T>, "Short type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE(T)    static_assert( ::blaze::IsSigned_v<T>, "Non-signed type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIGNED_TYPE(T)    static_assert( !::blaze::IsSigned_v<T>, "Signed type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_SIZE(T, S)    static_assert( ::blaze::HasSize_v<T,S>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE(T, S)    static_assert( !::blaze::HasSize_v<T,S>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE(T)    static_assert( ::blaze::Has1Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE(T)    static_assert( !::blaze::Has1Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES(T)    static_assert( ::blaze::Has2Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES(T)    static_assert( !::blaze::Has2Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES(T)    static_assert( ::blaze::Has4Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES(T)    static_assert( !::blaze::Has4Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES(T)    static_assert( ::blaze::Has8Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES(T)    static_assert( !::blaze::Has8Byte_v<T>, "Invalid size detected" )
 Constraint on the size of a data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE(T)    static_assert( sizeof( std::declval<T>()[0] ) > 0UL, "Non-subscriptable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBSCRIPTABLE_AS_DECAYABLE_POINTER(T)    static_assert( sizeof( 0[std::declval<T>()] ) > 0UL, "Non-subscriptable pointer detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_SOFT_TYPE_RESTRICTION(T, TYPELIST)    static_assert( ::blaze::ContainsRelated<TYPELIST,T>::value, "Unapproved type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_TYPE_RESTRICTION(T, TYPELIST)    static_assert( ::blaze::Contains<TYPELIST,T>::value, "Unapproved type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNION(T)    static_assert( ::blaze::IsUnion_v<T>, "Non-union type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNION(T)    static_assert( !::blaze::IsUnion_v<T>, "Union type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNSIGNED_TYPE(T)    static_assert( ::blaze::IsUnsigned_v<T>, "Non-unsigned type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNSIGNED_TYPE(T)    static_assert( !::blaze::IsUnsigned_v<T>, "Unsigned type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VALID_TYPE(T)    static_assert( blaze::IsValid_v<T>, "Invalid type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VALID_TYPE(T)    static_assert( !blaze::IsValid_v<T>, "Valid type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)    static_assert( blaze::IsVectorizable_v<T>, "Non-vectorizable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTORIZABLE_TYPE(T)    static_assert( !blaze::IsVectorizable_v<T>, "Vectorizable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VOID(T)    static_assert( ::blaze::IsVoid_v<T>, "Non-void type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOID(T)    static_assert( !::blaze::IsVoid_v<T>, "Void type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VOLATILE(T)    static_assert( ::blaze::IsVolatile_v<T>, "Non-volatile-qualified type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)    static_assert( !::blaze::IsVolatile_v<T>, "Volatile-qualified type detected" )
 Constraint on the data type. More...
 

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 ...

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

Macro Definition Documentation

◆ BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE (   T)     static_assert( ::blaze::IsArithmetic_v<T>, "Non-arithmetic type detected" )

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)     static_assert( ::blaze::IsArray_v<T>, "Non-array type detected" )

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,
 
)     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)     static_assert( ::blaze::IsBoolean_v<T>, "Non-boolean type detected" )

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)     static_assert( ::blaze::IsBuiltin_v<T>, "Non-built-in type detected" )

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)     static_assert( ::blaze::IsCharacter_v<T>, "Non-character type detected" )

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)     static_assert( ::blaze::IsClass_v<T>, "Non-class type detected" )

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)     static_assert( ::blaze::IsComplexDouble_v<T>, "Non-double precision complex type detected" )

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)     static_assert( ::blaze::IsComplexFloat_v<T>, "Non-single precision complex type detected" )

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)     static_assert( ::blaze::IsComplex_v<T>, "Non-complex type detected" )

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)     static_assert( ::blaze::IsConst_v<T>, "Non-const-qualified type detected" )

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 
)     static_assert( ::blaze::IsConvertible_v<FROM,TO>, "Inconvertible type detected" )

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)     static_assert( ::blaze::IsCopyAssignable_v<T>, "Non-copy assignable type detected" )

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)     static_assert( ::blaze::IsCopyConstructible_v<T>, "Non-copy constructible type detected" )

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)     static_assert( ::blaze::IsDefaultConstructible_v<T>, "Non-default constructible type detected" )

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,
 
)     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)     static_assert( ::blaze::IsDestructible_v<T>, "Non-destructible type detected" )

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)     static_assert( ::blaze::IsDouble_v<T>, "Non-double type detected" )

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)     static_assert( ::blaze::IsEmpty_v<T>, "Non-empty type detected" )

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)     static_assert( ::blaze::IsEnum_v<T>, "Non-enum type detected" )

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)     static_assert( ::blaze::IsFloat_v<T>, "Non-float type detected" )

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)     static_assert( ::blaze::IsFloatingPoint_v<T>, "Non-floating point type detected" )

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)     static_assert( ::blaze::IsInteger_v<T>, "Non-integer type detected" )

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)     static_assert( ::blaze::IsIntegral_v<T>, "Non-integral type detected" )

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)     static_assert( ::blaze::IsLong_v<T>, "Non-long type detected" )

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)     static_assert( ::blaze::IsLongDouble_v<T>, "Non-long double type detected" )

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)     static_assert( ::blaze::IsLValueReference_v<T>, "Non-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_BE_MOVE_ASSIGNABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MOVE_ASSIGNABLE_TYPE (   T)     static_assert( ::blaze::IsMoveAssignable_v<T>, "Non-move assignable type detected" )

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)     static_assert( ::blaze::IsMoveConstructible_v<T>, "Non-move constructible type detected" )

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)     static_assert( ::blaze::IsNothrowCopyAssignable_v<T>, "Non-noexcept copy assignable type detected" )

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)     static_assert( ::blaze::IsNothrowCopyConstructible_v<T>, "Non-noexcept copy constructible type detected" )

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)     static_assert( ::blaze::IsNothrowDefaultConstructible_v<T>, "Non-noexcept default constructible type detected" )

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)     static_assert( ::blaze::IsNothrowDestructible_v<T>, "Non-noexcept destructible type detected" )

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)     static_assert( ::blaze::IsNothrowMoveAssignable_v<T>, "Non-noexcept move assignable type detected" )

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)     static_assert( ::blaze::IsNothrowMoveConstructible_v<T>, "Non-noexcept move constructible type detected" )

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)     static_assert( ::blaze::IsNumeric_v<T>, "Non-numeric type detected" )

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)     static_assert( ::blaze::IsObject_v<T>, "Non-object type detected" )

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)     static_assert( ::blaze::IsPod_v<T>, "Non-POD type detected" )

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)     static_assert( ::blaze::IsPointer_v<T>, "Non-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_BE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE (   T)     static_assert( ::blaze::IsReference_v<T>, "Non-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_BE_RVALUE_REFERENCE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_RVALUE_REFERENCE_TYPE (   T)     static_assert( ::blaze::IsRValueReference_v<T>, "Non-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_BE_SAME_TAG

#define BLAZE_CONSTRAINT_MUST_BE_SAME_TAG (   A,
 
)     static_assert( ::blaze::IsSame_v<A,B>, "Non-matching tags detected" )

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,
 
)     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)     static_assert( ::blaze::IsShort_v<T>, "Non-short type detected" )

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)     static_assert( ::blaze::IsSigned_v<T>, "Non-signed type detected" )

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,
 
)     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,
 
)     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,
 
)     static_assert( ::blaze::IsStrictlySame_v<A,B>, "Non-matching types detected" )

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)     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)     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)     static_assert( ::blaze::IsUnion_v<T>, "Non-union type detected" )

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)     static_assert( ::blaze::IsUnsigned_v<T>, "Non-unsigned type detected" )

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)     static_assert( blaze::IsValid_v<T>, "Invalid type detected" )

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)     static_assert( blaze::IsVectorizable_v<T>, "Non-vectorizable type detected" )

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)     static_assert( ::blaze::IsVoid_v<T>, "Non-void type detected" )

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)     static_assert( ::blaze::IsVolatile_v<T>, "Non-volatile-qualified type detected" )

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)     static_assert( ::blaze::Has1Byte_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 1 byte, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES

#define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES (   T)     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)     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)     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 
)     static_assert( ::blaze::HasGreaterThan_v<T1,T2>, "Types without 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_HAVE_LESS_THAN_COMPARISON

#define BLAZE_CONSTRAINT_MUST_HAVE_LESS_THAN_COMPARISON (   T1,
  T2 
)     static_assert( ::blaze::HasLessThan_v<T1,T2>, "Types without 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_HAVE_RANK

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

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 
)     static_assert( ::blaze::HaveSameSize_v<T1,T2>, "Non-matching sizes detected" )

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,
 
)     static_assert( ::blaze::HasSize_v<T,S>, "Invalid size detected" )

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)     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)     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,
 
)     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)     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)     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)     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)     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)     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)     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)     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)     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 
)     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)     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)     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)     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,
 
)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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,
 
)     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,
 
)     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)     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)     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,
 
)     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,
 
)     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,
 
)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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)     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 
)     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 
)     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,
 
)     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 
)     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,
 
)     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 
)     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 
)     static_assert( ::blaze::ContainsRelated<TYPELIST,T>::value, "Unapproved type detected" )

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 
)     static_assert( ::blaze::Contains<TYPELIST,T>::value, "Unapproved type detected" )

Constraint on the data type.

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