![]() |
Macros | |
#define | BLAZE_CONSTRAINT_MUST_BE_ARITHMETIC_TYPE(T) static_assert( ::blaze::IsArithmetic<T>::value, "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_NOT_BE_ARITHMETIC_TYPE(T) static_assert( !::blaze::IsArithmetic<T>::value, "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_BE_ARRAY_TYPE(T) static_assert( ::blaze::IsArray<T>::value, "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_NOT_BE_ARRAY_TYPE(T) static_assert( !::blaze::IsArray<T>::value, "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_BE_COPY_ASSIGNABLE_TYPE(T) static_assert( ::blaze::IsCopyAssignable<T>::value, "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_NOT_BE_COPY_ASSIGNABLE_TYPE(T) static_assert( !::blaze::IsCopyAssignable<T>::value, "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_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T) static_assert( ::blaze::IsNothrowCopyAssignable<T>::value, "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_NOT_BE_NOTHROW_COPY_ASSIGNABLE_TYPE(T) static_assert( !::blaze::IsNothrowCopyAssignable<T>::value, "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_BE_MOVE_ASSIGNABLE_TYPE(T) static_assert( ::blaze::IsMoveAssignable<T>::value, "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_NOT_BE_MOVE_ASSIGNABLE_TYPE(T) static_assert( !::blaze::IsMoveAssignable<T>::value, "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_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T) static_assert( ::blaze::IsNothrowMoveAssignable<T>::value, "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_NOT_BE_NOTHROW_MOVE_ASSIGNABLE_TYPE(T) static_assert( !::blaze::IsNothrowMoveAssignable<T>::value, "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_BE_BASE_OF(B, D) static_assert( ::blaze::IsBaseOf<B,D>::value, "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_NOT_BE_BASE_OF(B, D) static_assert( !::blaze::IsBaseOf<B,D>::value, "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_BE_STRICTLY_BASE_OF(B, D) static_assert( ::blaze::IsBaseOf<B,D>::value && !::blaze::IsBaseOf<D,B>::value , "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_NOT_BE_STRICTLY_BASE_OF(B, D) static_assert( !::blaze::IsBaseOf<B,D>::value || ::blaze::IsBaseOf<D,B>::value , "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_BE_BOOLEAN_TYPE(T) static_assert( ::blaze::IsBoolean<T>::value, "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_NOT_BE_BOOLEAN_TYPE(T) static_assert( !::blaze::IsBoolean<T>::value, "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_BE_BUILTIN_TYPE(T) static_assert( ::blaze::IsBuiltin<T>::value, "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_NOT_BE_BUILTIN_TYPE(T) static_assert( !::blaze::IsBuiltin<T>::value, "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_BE_CLASS_TYPE(T) static_assert( ::blaze::IsClass<T>::value, "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_NOT_BE_CLASS_TYPE(T) static_assert( !::blaze::IsClass<T>::value, "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_POINTER_MUST_BE_COMPARABLE(P1, P2) static_assert( ::blaze::IsConvertible<P1,P2>::value || ::blaze::IsConvertible<P2,P1>::value, "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_MUST_BE_COMPLEX_TYPE(T) static_assert( ::blaze::IsComplex<T>::value, "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_NOT_BE_COMPLEX_TYPE(T) static_assert( !::blaze::IsComplex<T>::value, "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_BE_COMPLEX_DOUBLE_TYPE(T) static_assert( ::blaze::IsComplexDouble<T>::value, "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_NOT_BE_COMPLEX_DOUBLE_TYPE(T) static_assert( !::blaze::IsComplexDouble<T>::value, "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_BE_COMPLEX_FLOAT_TYPE(T) static_assert( ::blaze::IsComplexFloat<T>::value, "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_NOT_BE_COMPLEX_FLOAT_TYPE(T) static_assert( !::blaze::IsComplexFloat<T>::value, "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_BE_CONST(T) static_assert( ::blaze::IsConst<T>::value, "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_NOT_BE_CONST(T) static_assert( !::blaze::IsConst<T>::value, "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_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsDefaultConstructible<T>::value, "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_NOT_BE_DEFAULT_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsDefaultConstructible<T>::value, "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_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsNothrowDefaultConstructible<T>::value, "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_NOT_BE_NOTHROW_DEFAULT_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsNothrowDefaultConstructible<T>::value, "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_BE_COPY_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsCopyConstructible<T>::value, "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_NOT_BE_COPY_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsCopyConstructible<T>::value, "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_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsNothrowCopyConstructible<T>::value, "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_NOT_BE_NOTHROW_COPY_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsNothrowCopyConstructible<T>::value, "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_BE_MOVE_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsMoveConstructible<T>::value, "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_NOT_BE_MOVE_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsMoveConstructible<T>::value, "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_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsNothrowMoveConstructible<T>::value, "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_NOT_BE_NOTHROW_MOVE_CONSTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsNothrowMoveConstructible<T>::value, "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_BE_CONVERTIBLE(FROM, TO) static_assert( ::blaze::IsConvertible<FROM,TO>::value, "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_NOT_BE_CONVERTIBLE(FROM, TO) static_assert( !::blaze::IsConvertible<FROM,TO>::value, "Convertible type detected" ) |
Constraint on the pointer relationship.In case FROM is convertible to TO, a compilation error is created. | |
#define | BLAZE_CONSTRAINT_MUST_BE_DERIVED_FROM(D, B) static_assert( ( ::blaze::IsBaseOf<B,D>::value ), "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_NOT_BE_DERIVED_FROM(D, B) static_assert( ( !::blaze::IsBaseOf<B,D>::value ), "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_BE_STRICTLY_DERIVED_FROM(D, B) static_assert( ( ::blaze::IsBaseOf<B,D>::value && !::blaze::IsBaseOf<D,B>::value ), "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_NOT_BE_STRICTLY_DERIVED_FROM(D, B) static_assert( ( !::blaze::IsBaseOf<B,D>::value || ::blaze::IsBaseOf<D,B>::value ), "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_BE_DESTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsDestructible<T>::value, "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_NOT_BE_DESTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsDestructible<T>::value, "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_BE_NOTHROW_DESTRUCTIBLE_TYPE(T) static_assert( ::blaze::IsNothrowDestructible<T>::value, "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_NOT_BE_NOTHROW_DESTRUCTIBLE_TYPE(T) static_assert( !::blaze::IsNothrowDestructible<T>::value, "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_BE_DOUBLE_TYPE(T) static_assert( ::blaze::IsDouble<T>::value, "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_NOT_BE_DOUBLE_TYPE(T) static_assert( !::blaze::IsDouble<T>::value, "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_BE_EMPTY(T) static_assert( ::blaze::IsEmpty<T>::value, "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_NOT_BE_EMPTY(T) static_assert( !::blaze::IsEmpty<T>::value, "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_BE_FLOAT_TYPE(T) static_assert( ::blaze::IsFloat<T>::value, "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_NOT_BE_FLOAT_TYPE(T) static_assert( !::blaze::IsFloat<T>::value, "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_BE_FLOATING_POINT_TYPE(T) static_assert( ::blaze::IsFloatingPoint<T>::value, "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_NOT_BE_FLOATING_POINT_TYPE(T) static_assert( !::blaze::IsFloatingPoint<T>::value, "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_BE_INTEGER_TYPE(T) static_assert( ::blaze::IsInteger<T>::value, "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_NOT_BE_INTEGER_TYPE(T) static_assert( !::blaze::IsInteger<T>::value, "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_BE_INTEGRAL_TYPE(T) static_assert( ::blaze::IsIntegral<T>::value, "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_NOT_BE_INTEGRAL_TYPE(T) static_assert( !::blaze::IsIntegral<T>::value, "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_BE_LONGDOUBLE_TYPE(T) static_assert( ::blaze::IsLongDouble<T>::value, "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_NOT_BE_LONGDOUBLE_TYPE(T) static_assert( !::blaze::IsLongDouble<T>::value, "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_BE_NUMERIC_TYPE(T) static_assert( ::blaze::IsNumeric<T>::value, "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_NOT_BE_NUMERIC_TYPE(T) static_assert( !::blaze::IsNumeric<T>::value, "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_BE_OBJECT_TYPE(T) static_assert( ::blaze::IsObject<T>::value, "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_NOT_BE_OBJECT_TYPE(T) static_assert( !::blaze::IsObject<T>::value, "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_BE_POD(T) static_assert( ::blaze::IsPod<T>::value, "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_NOT_BE_POD(T) static_assert( !::blaze::IsPod<T>::value, "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_BE_POINTER_TYPE(T) static_assert( ::blaze::IsPointer<T>::value, "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_NOT_BE_POINTER_TYPE(T) static_assert( !::blaze::IsPointer<T>::value, "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_HAVE_RANK(T, N) static_assert( ::blaze::Rank<T>::value == 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_NOT_HAVE_RANK(T, N) static_assert( ::blaze::Rank<T>::value != 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_BE_REFERENCE_TYPE(T) static_assert( ::blaze::IsReference<T>::value, "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_NOT_BE_REFERENCE_TYPE(T) static_assert( !::blaze::IsReference<T>::value, "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_HAVE_SAME_SIZE(T1, T2) static_assert( ::blaze::HaveSameSize<T1,T2>::value, "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_NOT_HAVE_SAME_SIZE(T1, T2) static_assert( !::blaze::HaveSameSize<T1,T2>::value, "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_BE_SAME_TYPE(A, B) static_assert( ::blaze::IsSame<A,B>::value, "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: More... | |
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SAME_TYPE(A, B) static_assert( !::blaze::IsSame<A,B>::value, "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: More... | |
#define | BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B) static_assert( ::blaze::IsStrictlySame<A,B>::value, "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. More... | |
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_SAME_TYPE(A, B) static_assert( !::blaze::IsStrictlySame<A,B>::value, "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. More... | |
#define | BLAZE_CONSTRAINT_MUST_BE_SIGNED_TYPE(T) static_assert( ::blaze::IsSigned<T>::value, "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_NOT_BE_SIGNED_TYPE(T) static_assert( !::blaze::IsSigned<T>::value, "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_HAVE_SIZE(T, S) static_assert( ::blaze::HasSize<T,S>::value, "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_HAVE_SIZE(T, S) static_assert( !::blaze::HasSize<T,S>::value, "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_MUST_HAVE_1_BYTE(T) static_assert( ::blaze::Has1Byte<T>::value, "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_NOT_HAVE_1_BYTE(T) static_assert( !::blaze::Has1Byte<T>::value, "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_HAVE_2_BYTES(T) static_assert( ::blaze::Has2Byte<T>::value, "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_NOT_HAVE_2_BYTES(T) static_assert( !::blaze::Has2Byte<T>::value, "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_HAVE_4_BYTES(T) static_assert( ::blaze::Has4Byte<T>::value, "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_NOT_HAVE_4_BYTES(T) static_assert( !::blaze::Has4Byte<T>::value, "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_HAVE_8_BYTES(T) static_assert( ::blaze::Has8Byte<T>::value, "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_NOT_HAVE_8_BYTES(T) static_assert( !::blaze::Has8Byte<T>::value, "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_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_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. | |
#define | BLAZE_CONSTRAINT_MUST_BE_UNION(T) static_assert( ::blaze::IsUnion<T>::value, "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_NOT_BE_UNION(T) static_assert( !::blaze::IsUnion<T>::value, "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_BE_UNSIGNED_TYPE(T) static_assert( ::blaze::IsUnsigned<T>::value, "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_NOT_BE_UNSIGNED_TYPE(T) static_assert( !::blaze::IsUnsigned<T>::value, "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_BE_VALID_TYPE(T) static_assert( blaze::IsValid<T>::value, "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_NOT_BE_VALID_TYPE(T) static_assert( !blaze::IsValid<T>::value, "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_BE_VECTORIZABLE_TYPE(T) static_assert( blaze::IsVectorizable<T>::value, "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_NOT_BE_VECTORIZABLE_TYPE(T) static_assert( !blaze::IsVectorizable<T>::value, "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_BE_VOID(T) static_assert( ::blaze::IsVoid<T>::value, "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_NOT_BE_VOID(T) static_assert( !::blaze::IsVoid<T>::value, "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_BE_VOLATILE(T) static_assert( ::blaze::IsVolatile<T>::value, "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_NOT_BE_VOLATILE(T) static_assert( !::blaze::IsVolatile<T>::value, "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. | |
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_SAME_TYPE | ( | A, | |
B | |||
) | static_assert( ::blaze::IsSame<A,B>::value, "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_STRICTLY_SAME_TYPE | ( | A, | |
B | |||
) | static_assert( ::blaze::IsStrictlySame<A,B>::value, "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_NOT_BE_SAME_TYPE | ( | A, | |
B | |||
) | static_assert( !::blaze::IsSame<A,B>::value, "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_STRICTLY_SAME_TYPE | ( | A, | |
B | |||
) | static_assert( !::blaze::IsStrictlySame<A,B>::value, "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.