![]() |
Blaze 3.9
|
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... | |
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:
The Blaze library extends this functionality in the form of compile time constraint macros:
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:
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:
#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.
#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.
#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.
In case B is not a base class of D, a compilation error is created.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
In case D is not derived from B, a compilation error is created.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TAG | ( | A, | |
B | |||
) | 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:
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE | ( | A, | |
B | |||
) | 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:
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_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.
#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.
#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.
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, | |
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.
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, | |
B | |||
) | 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.
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 | ) | 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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
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 | |||
) | 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.
#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.
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 | ) | 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.
#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.
#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.
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 | ) | 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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
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_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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TAG | ( | A, | |
B | |||
) | 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:
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE | ( | A, | |
B | |||
) | 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:
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_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.
#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.
#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.
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, | |
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.
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, | |
B | |||
) | 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.
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 | ) | 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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
#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.
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 | |||
) | 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.
#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.
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 | |||
) | 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.
#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.
#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.