Classes | Typedefs
Type traits

Classes

struct  blaze::AddConst< T >
 Addition of a top level 'const' qualifier.The AddConst type trait adds a top level 'const' qualifier to the given type T. More...
 
struct  blaze::AddCV< T >
 Addition of a top level 'const' and 'volatile' qualifier.The AddCV type trait adds both a top level 'const' and 'volatile' qualifier to the given type T. More...
 
struct  blaze::AddPointer< T >
 Addition of a top level pointer.The AddPointer type trait adds a top level pointer to the given type T. It has the same effect as blaze::RemovePointer<T>::Type*. More...
 
struct  blaze::AddReference< T >
 Addition of a top level reference.In case the given type T is not a reference type, the AddReference type trait adds a top level reference to the given type T. Else the resulting type Type is T. More...
 
struct  blaze::AddVolatile< T >
 Addition of a top level 'volatile' qualifier.The AddVolatile type trait adds a top level 'volatile' qualifier to the given type T. More...
 
struct  blaze::AlignmentOf< T >
 Evaluation of the required alignment of the given data type.The AlignmentOf type trait template evaluates the required alignment for the given data type. For instance, for fundamental data types that can be vectorized via SSE or AVX instructions, the proper alignment is 16 or 32 bytes, respectively. For all other data types, a multiple of the alignment chosen by the compiler is returned. The evaluated alignment can be queried via the nested value member. More...
 
struct  blaze::All< TypeTrait, T1, T2, Ts >
 Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for all given types Ts. If the expression. More...
 
struct  blaze::Any< TypeTrait, T1, T2, Ts >
 Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for at least one of the given types Ts. If the expression. More...
 
struct  blaze::CommonType< T >
 Deduction of a type common to several types.The CommonType type trait deduces the result type of a mixed-mode arithmetic expression between all types T..., that is the type all T... can be implicitly converted to. Note that cv and reference qualifiers are generally ignored. More...
 
struct  blaze::Decay< T >
 Applies the type conversions for by-value function arguments.This type trait applies the type conversions that are used for by-value function arguments. This conversions include lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T, and the removal of top level cv-qualifiers. More...
 
struct  blaze::Extent< T, N >
 Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member constant is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0. More...
 
struct  blaze::HasSize< T, Size >
 Compile time size check.This class offers the possibility to test the size of a type at compile time. If the type T is exactly Size bytes large, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has1Byte< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly one byte. If the type T has one byte, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has2Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly two bytes. If the type T has two bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has4Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has8Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives fromTrueType. Otherwise value is set to false, Type is FalseType, and the classderives from FalseType. More...
 
class  blaze::HaveSameSize< T1, T2 >
 Compile time size check.This class offers the possibility to test the size of two types at compile time. If an object of type T1 has the same size as an object of type T2, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsArithmetic< T >
 Compile time check for arithmetic data types.This type trait tests whether or not the given template parameter is a (possibly cv-qualified) arithmetic (integral or floating point) data type. In case the type is an arithmetic type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsArray< T >
 Compile time type check.The IsArray type trait tests whether or not the given template parameter is an array type. In case the given data type is an array type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsAssignable< T, U >
 Compile time type check.The IsAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowAssignable< T, U >
 Compile time type check.The IsNothrowAssignable type trait tests whether the expression. More...
 
struct  blaze::IsCopyAssignable< T >
 Compile time type check.The IsCopyAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowCopyAssignable< T >
 Compile time type check.The IsNothrowCopyAssignable type trait tests whether the expression. More...
 
struct  blaze::IsMoveAssignable< T >
 Compile time type check.The IsMoveAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowMoveAssignable< T >
 Compile time type check.The IsNothrowMoveAssignable type trait tests whether the expression. More...
 
class  blaze::IsBaseOf< Base, Derived >
 Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member contant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBoolean< T >
 Compile time check for boolean types.This type trait tests whether or not the given template parameter is of boolean type. In case the type is a boolean (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBuiltin< T >
 Compile time check for built-in data types.This type trait tests whether or not the given template parameter is a built-in/fundamental data type. In case the type is a built-in type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsCharacter< T >
 Compile time check for character types.This type trait tests whether or not the given template parameter is a character type (i.e., either char, signed char, unsigned char, or wchar_t, possibly cv-qualified). In case the type is a character type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsClass< T >
 Compile time type check.The IsClass type trait tests whether or not the given template parameter is a (possibly cv-qualified) class type. In case the given data type is a class type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsComplex< T >
 Compile time check for complex types.This type trait tests whether or not the given template parameter is a complex data type. In case the type is a complex data type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsComplexDouble< T >
 Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<double>. In case the type is complex<double> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsComplexFloat< T >
 Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<float>. In case the type is complex<float> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsConst< T >
 Compile time check for constant data types.The IsConst type trait tests whether or not the given template parameter is a (top level) const-qualified data type. In case the given data type is const-qualified, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsConstructible< T, Args >
 Compile time type check.The IsConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowConstructible< T, Args >
 Compile time type check.The IsNothrowConstructible type trait tests whether the expression. More...
 
struct  blaze::IsDefaultConstructible< T >
 Compile time type check.The IsDefaultConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowDefaultConstructible< T >
 Compile time type check.The IsNothrowDefaultConstructible type trait tests whether the expression. More...
 
struct  blaze::IsCopyConstructible< T >
 Compile time type check.The IsCopyConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowCopyConstructible< T >
 Compile time type check.The IsNothrowCopyConstructible type trait tests whether the expression. More...
 
struct  blaze::IsMoveConstructible< T >
 Compile time type check.The IsMoveConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowMoveConstructible< T >
 Compile time type check.The IsNothrowMoveConstructible type trait tests whether the expression. More...
 
struct  blaze::IsConvertible< From, To >
 Compile time pointer relationship constraint.This type traits tests whether the first given template argument can be converted to the second template argument via copy construction. If the first argument can be converted to the second argument, the value member constnt is set to true, the nested type definition type is TrueType, and the class derives from TrueType. Otherwise value is set to false, type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDestructible< T >
 Compile time type check.The IsDestructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowDestructible< T >
 Compile time type check.The IsDestructible type trait tests whether the expression. More...
 
struct  blaze::IsDouble< T >
 Compile time check for double precision floating point types.This type trait tests whether or not the given template parameter is of double type. In case the type is double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsEmpty< T >
 Compile time type check.This class tests whether the given template parameter is an empty class type, i.e. a type without member data and virtual functions. If it is an empty class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsEnum< T >
 Compile time check for complete enumeration types.This type trait tests whether or not the given template parameter is an enumeration type. In case the type is an enumeration type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsFloat< T >
 Compile time check for single precision floating point types.This type trait tests whether or not the given template parameter is of float type. In case the type is float (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsFloatingPoint< T >
 Compile time check for floating point data types.This type trait tests whether or not the given template parameter is a floating point data type (ignoring the cv-qualifiers). In case the type is a floating point data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsInteger< T >
 Compile time check for integer types.This type trait tests whether or not the given template parameter is an integer type (i.e., either (signed) int or unsigned int, possibly cv-qualified). In case the type is an integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsIntegral< T >
 Compile time check for integral data types.This type trait tests whether or not the given template parameter is an integral data type. In case the type is an integral data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLong< T >
 Compile time check for long integer types.This type trait tests whether or not the given template parameter is a long integer type (i.e., either (signed) long or unsigned long, possibly cv-qualified). In case the type is a long integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLongDouble< T >
 Compile time check for extended precision floating point types.This type trait tests whether or not the given template parameter is of long double type. In case the type is long double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLValueReference< T >
 Compile time type check.This class tests whether the given template parameter T is an lvalue reference type. If it is an lvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsNumeric< T >
 Compile time check for numeric types.This type trait tests whether or not the given template parameter is a numeric data type. Blaze considers all integral (except bool), floating point, and complex data types as numeric data types. In case the type is a numeric type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsObject< T >
 Compile time type check.This class tests whether the given template parameter T is an object type. All types are considered object types except references, void, and function types. If T is an object type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsPod< T >
 Compile time check for pod data types.This type trait tests whether or not the given template parameter is a POD (Plain Old Data). In case the type is a POD, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsPointer< T >
 Compile time type check.This class tests whether the given template parameter is a pointer type (including function pointers, but excluding pointers to members) or not. If it is a pointer type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsReference< T >
 Compile time type check.This class tests whether the given template parameter T is a reference type (including references to functions). If it is a reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsRValueReference< T >
 Compile time type check.This class tests whether the given template parameter T is an rvalue reference type. If it is an rvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsStrictlySame< A, B >
 Compile time type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are not ignored. If A and B are the same data type, then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSame< A, B >
 Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsShort< T >
 Compile time check for short integer types.This type trait tests whether or not the given template parameter is a short integer type (i.e., either (signed) short or unsigned short, possibly cv-qualified). In case the type is a short integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSigned< T >
 Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral or a floating point data type. In case the type is a signed (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUnion< T >
 Compile time check for union data types.This type trait tests whether or not the given template parameter is a union data type. In case the type is a union, the value member constant is set o true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUnsigned< T >
 Compile time check for unsigned data types.This type trait tests whether or not the given template parameter is an unsigned, integral data type. In case the type is an unsigned (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsValid< T >
 Compile time type check.This class tests whether the given template parameter is a valid or invalid data type (i.e. if the type is the INVALID_TYPE). If T is not the INVALID_TYPE class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVectorizable< T >
 Compile time check for vectorizable types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), this type trait tests whether or not the given template parameter is a vectorizable type, i.e. a type for which intrinsic vector operations and optimizations can be used. Currently, all built-in data types except bool and the according complex numbers are considered to be vectorizable types. In case the type is vectorizable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVoid< T >
 Compile time check for the void data type.This type trait tests whether or not the given template parameter is of type void (ignoring the cv-qualifiers). In case the type is of type void, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVolatile< T >
 Compile time check for volatile data types.The IsVolatile type trait tests whether or not the given template parameter is a (top level) volatile-qualified data type. In case the given data type is volatile, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::MakeSigned< T >
 Compile time type conversion into a signed integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding signed integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More...
 
struct  blaze::MakeUnsigned< T >
 Compile time type conversion into an unsigned integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding unsigned integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More...
 
struct  blaze::Rank< T >
 Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member constant is set to the number of dimensions of T. Otherwise value is set to 0. More...
 
struct  blaze::RemoveAllExtents< T >
 Removal of all array extents.The RemoveAllExtents type trait removes all array extents from the given type T. More...
 
struct  blaze::RemoveConst< T >
 Removal of const-qualifiers.The RemoveConst type trait removes all top level 'const' qualifiers from the given type T. More...
 
struct  blaze::RemoveCV< T >
 Removal of top level cv-qualifiers.The RemoveCV type trait removes all top level cv-qualifiers from the given type T. More...
 
struct  blaze::RemoveExtent< T >
 Removal of the top level array extent.The RemoveExtent type trait removes the top level array extent from the given type T. More...
 
struct  blaze::RemovePointer< T >
 Removal of pointer modifiers.The RemovePointer type trait removes any pointer modifiers from the given type T. More...
 
struct  blaze::RemoveReference< T >
 Removal of reference modifiers.The RemoveReference type trait removes any reference modifiers from the given type T. More...
 
struct  blaze::RemoveVolatile< T >
 Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T. More...
 

Typedefs

template<typename T1 , typename T2 >
using blaze::HighType_ = typename HighType< T1, T2 >::Type
 Auxiliary alias declaration for the HighType type trait.The HighType_ alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::LowType_ = typename LowType< T1, T2 >::Type
 Auxiliary alias declaration for the LowType type trait.The LowType_ alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveAdaptor_ = typename RemoveAdaptor< T >::Type
 Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingBuiltin_ = typename UnderlyingBuiltin< T >::Type
 Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingElement_ = typename UnderlyingElement< T >::Type
 Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingNumeric_ = typename UnderlyingNumeric< T >::Type
 Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddConst_ = typename AddConst< T >::Type
 Auxiliary alias declaration for the AddConst type trait.The AddConst_ alias declaration provides a convenient shortcut to access the nested Type of the AddConst class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddCV_ = typename AddCV< T >::Type
 Auxiliary alias declaration for the AddCV type trait.The AddCV_ alias declaration provides a convenient shortcut to access the nested Type of the AddCV class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddPointer_ = typename AddPointer< T >::Type
 Auxiliary alias declaration for the AddPointer type trait.The AddPointer_ alias declaration provides a convenient shortcut to access the nested Type of the AddPointer class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddReference_ = typename AddReference< T >::Type
 Auxiliary alias declaration for the AddReference type trait.The AddReference_ alias declaration provides a convenient shortcut to access the nested Type of the AddReference class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddVolatile_ = typename AddVolatile< T >::Type
 Auxiliary alias declaration for the AddVolatile type trait.The AddVolatile_ alias declaration provides a convenient shortcut to access the nested Type of the AddVolatile class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename... T>
using blaze::CommonType_ = typename CommonType< T... >::Type
 Auxiliary alias declaration for the CommonType type trait.The CommonType_ alias declaration provides a convenient shortcut to access the nested Type of the CommonType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::Decay_ = typename Decay< T >::Type
 Auxiliary alias declaration for the Decay type trait.The Decay_ alias declaration provides a convenient shortcut to access the nested Type of the Decay class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::MakeSigned_ = typename MakeSigned< T >::Type
 Auxiliary alias declaration for the MakeSigned type trait.The MakeSigned_ alias declaration provides a convenient shortcut to access the nested Type of the MakeSigned class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::MakeUnsigned_ = typename MakeUnsigned< T >::Type
 Auxiliary alias declaration for the MakeUnsigned type trait.The MakeUnsigned_ alias declaration provides a convenient shortcut to access the nested Type of the MakeUnsigned class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveAllExtents_ = typename RemoveAllExtents< T >::Type
 Auxiliary alias declaration for the RemoveAllExtents type trait.The RemoveAllExtents_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveAllExtents class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveConst_ = typename RemoveConst< T >::Type
 Auxiliary alias declaration for the RemoveConst type trait.The RemoveConst_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveConst class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveCV_ = typename RemoveCV< T >::Type
 Auxiliary alias declaration for the RemoveCV type trait.The RemoveCV_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveCV class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveExtent_ = typename RemoveExtent< T >::Type
 Auxiliary alias declaration for the RemoveExtent type trait.The RemoveExtent_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveExtent class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemovePointer_ = typename RemovePointer< T >::Type
 Auxiliary alias declaration for the RemovePointer type trait.The RemovePointer_ alias declaration provides a convenient shortcut to access the nested Type of the RemovePointer class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveReference_ = typename RemoveReference< T >::Type
 Auxiliary alias declaration for the RemoveReference type trait.The RemoveReference_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveReference class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveVolatile_ = typename RemoveVolatile< T >::Type
 Auxiliary alias declaration for the RemoveVolatile type trait.The RemoveVolatile_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveVolatile class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename... Ts>
using blaze::Void_ = void
 Compile time type check.This type trait maps an arbitrary sequence of types to the type void. It can for instance be used to determine the validity of an expression: More...
 

Detailed Description

Typedef Documentation

◆ AddConst_

template<typename T >
using blaze::AddConst_ = typedef typename AddConst<T>::Type

Auxiliary alias declaration for the AddConst type trait.The AddConst_ alias declaration provides a convenient shortcut to access the nested Type of the AddConst class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename AddConst<T>::Type;
using Type2 = AddConst_<T>;

◆ AddCV_

template<typename T >
using blaze::AddCV_ = typedef typename AddCV<T>::Type

Auxiliary alias declaration for the AddCV type trait.The AddCV_ alias declaration provides a convenient shortcut to access the nested Type of the AddCV class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename AddCV<T>::Type;
using Type2 = AddCV_<T>;

◆ AddPointer_

template<typename T >
using blaze::AddPointer_ = typedef typename AddPointer<T>::Type

Auxiliary alias declaration for the AddPointer type trait.The AddPointer_ alias declaration provides a convenient shortcut to access the nested Type of the AddPointer class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename AddPointer<T>::Type;
using Type2 = AddPointer_<T>;

◆ AddReference_

template<typename T >
using blaze::AddReference_ = typedef typename AddReference<T>::Type

Auxiliary alias declaration for the AddReference type trait.The AddReference_ alias declaration provides a convenient shortcut to access the nested Type of the AddReference class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename AddReference<T>::Type;
using Type2 = AddReference_<T>;

◆ AddVolatile_

template<typename T >
using blaze::AddVolatile_ = typedef typename AddVolatile<T>::Type

Auxiliary alias declaration for the AddVolatile type trait.The AddVolatile_ alias declaration provides a convenient shortcut to access the nested Type of the AddVolatile class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename AddVolatile<T>::Type;
using Type2 = AddVolatile_<T>;

◆ CommonType_

template<typename... T>
using blaze::CommonType_ = typedef typename CommonType<T...>::Type

Auxiliary alias declaration for the CommonType type trait.The CommonType_ alias declaration provides a convenient shortcut to access the nested Type of the CommonType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename CommonType<T1,T2>::Type;
using Type2 = CommonType_<T1,T2>;

◆ Decay_

template<typename T >
using blaze::Decay_ = typedef typename Decay<T>::Type

Auxiliary alias declaration for the Decay type trait.The Decay_ alias declaration provides a convenient shortcut to access the nested Type of the Decay class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename Decay<T>::Type;
using Type2 = Decay_<T>;

◆ HighType_

template<typename T1 , typename T2 >
using blaze::HighType_ = typedef typename HighType<T1,T2>::Type

Auxiliary alias declaration for the HighType type trait.The HighType_ alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename HighType<T1,T2>::Type;
using Type2 = HighType_<T1,T2>;

◆ LowType_

template<typename T1 , typename T2 >
using blaze::LowType_ = typedef typename LowType<T1,T2>::Type

Auxiliary alias declaration for the LowType type trait.The LowType_ alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename LowType<T1,T2>::Type;
using Type2 = LowType_<T1,T2>;

◆ MakeSigned_

template<typename T >
using blaze::MakeSigned_ = typedef typename MakeSigned<T>::Type

Auxiliary alias declaration for the MakeSigned type trait.The MakeSigned_ alias declaration provides a convenient shortcut to access the nested Type of the MakeSigned class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename MakeSigned<T>::Type;
using Type2 = MakeSigned_<T>;

◆ MakeUnsigned_

template<typename T >
using blaze::MakeUnsigned_ = typedef typename MakeUnsigned<T>::Type

Auxiliary alias declaration for the MakeUnsigned type trait.The MakeUnsigned_ alias declaration provides a convenient shortcut to access the nested Type of the MakeUnsigned class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename MakeUnsigned<T>::Type;
using Type2 = MakeUnsigned_<T>;

◆ RemoveAdaptor_

template<typename T >
using blaze::RemoveAdaptor_ = typedef typename RemoveAdaptor<T>::Type

Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveAdaptor<T>::Type;
using Type2 = RemoveAdaptor_<T>;

◆ RemoveAllExtents_

template<typename T >
using blaze::RemoveAllExtents_ = typedef typename RemoveAllExtents<T>::Type

Auxiliary alias declaration for the RemoveAllExtents type trait.The RemoveAllExtents_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveAllExtents class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveAllExtents<T>::Type;
using Type2 = RemoveAllExtents_<T>;

◆ RemoveConst_

template<typename T >
using blaze::RemoveConst_ = typedef typename RemoveConst<T>::Type

Auxiliary alias declaration for the RemoveConst type trait.The RemoveConst_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveConst class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveConst<T>::Type;
using Type2 = RemoveConst_<T>;

◆ RemoveCV_

template<typename T >
using blaze::RemoveCV_ = typedef typename RemoveCV<T>::Type

Auxiliary alias declaration for the RemoveCV type trait.The RemoveCV_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveCV class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveCV<T>::Type;
using Type2 = RemoveCV_<T>;

◆ RemoveExtent_

template<typename T >
using blaze::RemoveExtent_ = typedef typename RemoveExtent<T>::Type

Auxiliary alias declaration for the RemoveExtent type trait.The RemoveExtent_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveExtent class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveExtent<T>::Type;
using Type2 = RemoveExtent_<T>;

◆ RemovePointer_

template<typename T >
using blaze::RemovePointer_ = typedef typename RemovePointer<T>::Type

Auxiliary alias declaration for the RemovePointer type trait.The RemovePointer_ alias declaration provides a convenient shortcut to access the nested Type of the RemovePointer class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemovePointer<T>::Type;
using Type2 = RemovePointer_<T>;

◆ RemoveReference_

template<typename T >
using blaze::RemoveReference_ = typedef typename RemoveReference<T>::Type

Auxiliary alias declaration for the RemoveReference type trait.The RemoveReference_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveReference class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveReference<T>::Type;
using Type2 = RemoveReference_<T>;

◆ RemoveVolatile_

template<typename T >
using blaze::RemoveVolatile_ = typedef typename RemoveVolatile<T>::Type

Auxiliary alias declaration for the RemoveVolatile type trait.The RemoveVolatile_ alias declaration provides a convenient shortcut to access the nested Type of the RemoveVolatile class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RemoveVolatile<T>::Type;
using Type2 = RemoveVolatile_<T>;

◆ UnderlyingBuiltin_

template<typename T >
using blaze::UnderlyingBuiltin_ = typedef typename UnderlyingBuiltin<T>::Type

Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename UnderlyingBuiltin<T>::Type;
using Type2 = UnderlyingBuiltin_<T>;

◆ UnderlyingElement_

template<typename T >
using blaze::UnderlyingElement_ = typedef typename UnderlyingElement<T>::Type

Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename UnderlyingElement<T>::Type;
using Type2 = UnderlyingElement_<T>;

◆ UnderlyingNumeric_

template<typename T >
using blaze::UnderlyingNumeric_ = typedef typename UnderlyingNumeric<T>::Type

Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_ alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename UnderlyingNumeric<T>::Type;
using Type2 = UnderlyingNumeric_<T>;

◆ Void_

template<typename... Ts>
using blaze::Void_ = typedef void

Compile time type check.This type trait maps an arbitrary sequence of types to the type void. It can for instance be used to determine the validity of an expression:

template< typename T1, typename T2, typename = Void_<> >
struct HasAdd : public FalseType {};
template< typename T1, typename T2
, Void_< decltype( std::declval<T1>() + std::declval<T2>() ) >
struct HasAdd : public TrueType {};