Blaze 3.9
Loading...
Searching...
No Matches
Type traits

Classes

struct  blaze::MakeComplex< T >
 Converting the given type to the matching 'complex' type. More...
struct  blaze::AddConst< T >
 Addition of a top level 'const' qualifier. More...
struct  blaze::AddCV< T >
 Addition of a top level 'const' and 'volatile' qualifier. More...
struct  blaze::AddLValueReference< T >
 Addition of a top level reference. More...
struct  blaze::AddPointer< T >
 Addition of a top level pointer. More...
struct  blaze::AddRValueReference< T >
 Addition of a top level reference. More...
struct  blaze::AddVolatile< T >
 Addition of a top level 'volatile' qualifier. More...
struct  blaze::AlignmentOf< T >
 Evaluation of the required alignment of the given data type. More...
struct  blaze::All< TypeTrait, T1, T2, Ts >
 Compile time type check. More...
struct  blaze::AlwaysFalse< T >
 Type dependent compile time false. More...
struct  blaze::AlwaysTrue< T >
 Type dependent compile time true. More...
struct  blaze::Any< TypeTrait, T1, T2, Ts >
 Compile time type check. More...
struct  blaze::CommonType< T >
 Deduction of a type common to several types. More...
struct  blaze::Decay< T >
 Applies the type conversions for by-value function arguments. More...
struct  blaze::Extent< T, N >
 Compile time check for the size of array bounds. More...
struct  blaze::HasSize< T, S >
 Compile time size check. More...
struct  blaze::Has1Byte< T >
 Compile time size check. More...
struct  blaze::Has2Bytes< T >
 Compile time size check. More...
struct  blaze::Has4Bytes< T >
 Compile time size check. More...
struct  blaze::Has8Bytes< T >
 Compile time size check. More...
class  blaze::HaveSameSize< T1, T2 >
 Compile time size check. More...
struct  blaze::IsArithmetic< T >
 Compile time check for arithmetic data types. More...
struct  blaze::IsArray< T >
 Compile time type check. More...
struct  blaze::IsAssignable< T, U >
 Compile time type check. More...
struct  blaze::IsNothrowAssignable< T, U >
 Compile time type check. More...
struct  blaze::IsCopyAssignable< T >
 Compile time type check. More...
struct  blaze::IsNothrowCopyAssignable< T >
 Compile time type check. More...
struct  blaze::IsMoveAssignable< T >
 Compile time type check. More...
struct  blaze::IsNothrowMoveAssignable< T >
 Compile time type check. More...
class  blaze::IsBaseOf< Base, Derived >
 Compile time analysis of an inheritance relationship. More...
struct  blaze::IsBoolean< T >
 Compile time check for boolean types. More...
struct  blaze::IsBuiltin< T >
 Compile time check for built-in data types. More...
struct  blaze::IsCharacter< T >
 Compile time check for character types. More...
struct  blaze::IsClass< T >
 Compile time type check. More...
struct  blaze::IsComplex< T >
 Compile time check for complex types. More...
struct  blaze::IsComplexDouble< T >
 Compile time check for single precision complex types. More...
struct  blaze::IsComplexFloat< T >
 Compile time check for single precision complex types. More...
struct  blaze::IsConst< T >
 Compile time check for constant data types. More...
struct  blaze::IsConstructible< T, Args >
 Compile time type check. More...
struct  blaze::IsNothrowConstructible< T, Args >
 Compile time type check. More...
struct  blaze::IsDefaultConstructible< T >
 Compile time type check. More...
struct  blaze::IsNothrowDefaultConstructible< T >
 Compile time type check. More...
struct  blaze::IsCopyConstructible< T >
 Compile time type check. More...
struct  blaze::IsNothrowCopyConstructible< T >
 Compile time type check. More...
struct  blaze::IsMoveConstructible< T >
 Compile time type check. More...
struct  blaze::IsNothrowMoveConstructible< T >
 Compile time type check. More...
struct  blaze::IsConvertible< From, To >
 Compile time pointer relationship constraint. More...
struct  blaze::IsDestructible< T >
 Compile time type check. More...
struct  blaze::IsNothrowDestructible< T >
 Compile time type check. More...
struct  blaze::NoneSuch
 Default result type for the Detected_t type trait. More...
struct  blaze::IsDouble< T >
 Compile time check for double precision floating point types. More...
struct  blaze::IsEmpty< T >
 Compile time type check. More...
struct  blaze::IsEnum< T >
 Compile time check for complete enumeration types. More...
struct  blaze::IsFloat< T >
 Compile time check for single precision floating point types. More...
struct  blaze::IsFloatingPoint< T >
 Compile time check for floating point data types. More...
struct  blaze::IsInteger< T >
 Compile time check for integer types. More...
struct  blaze::IsIntegral< T >
 Compile time check for integral data types. More...
struct  blaze::IsLong< T >
 Compile time check for long integer types. More...
struct  blaze::IsLongDouble< T >
 Compile time check for extended precision floating point types. More...
struct  blaze::IsLValueReference< T >
 Compile time type check. More...
struct  blaze::IsNumeric< T >
 Compile time check for numeric types. More...
struct  blaze::IsObject< T >
 Compile time type check. More...
struct  blaze::IsPod< T >
 Compile time check for pod data types. More...
struct  blaze::IsPointer< T >
 Compile time type check. More...
struct  blaze::IsReference< T >
 Compile time type check. More...
struct  blaze::IsRValueReference< T >
 Compile time type check. More...
struct  blaze::IsStrictlySame< A, B >
 Compile time type relationship analysis. More...
struct  blaze::IsSame< A, B >
 Type relationship analysis. More...
struct  blaze::IsShort< T >
 Compile time check for short integer types. More...
struct  blaze::IsSigned< T >
 Compile time check for signed data types. More...
struct  blaze::IsUnion< T >
 Compile time check for union data types. More...
struct  blaze::IsUnsigned< T >
 Compile time check for unsigned data types. More...
struct  blaze::IsValid< T >
 Compile time type check. More...
struct  blaze::IsVectorizable< T >
 Compile time check for vectorizable types. More...
struct  blaze::IsVoid< T >
 Compile time check for the void data type. More...
struct  blaze::IsVolatile< T >
 Compile time check for volatile data types. More...
struct  blaze::MakeSigned< T >
 Compile time type conversion into a signed integral type. More...
struct  blaze::MakeUnsigned< T >
 Compile time type conversion into an unsigned integral type. More...
struct  blaze::Rank< T >
 Compile time check for array ranks. More...
struct  blaze::RemoveAllExtents< T >
 Removal of all array extents. More...
struct  blaze::RemoveConst< T >
 Removal of const-qualifiers. More...
struct  blaze::RemoveCV< T >
 Removal of top level cv-qualifiers. More...
struct  blaze::RemoveCVRef< T >
 Removal of top level cv-qualifiers. More...
struct  blaze::RemoveExtent< T >
 Removal of the top level array extent. More...
struct  blaze::RemoveLValueReference< T >
 Removal of reference modifiers. More...
struct  blaze::RemovePointer< T >
 Removal of pointer modifiers. More...
struct  blaze::RemoveReference< T >
 Removal of reference modifiers. More...
struct  blaze::RemoveRValueReference< T >
 Removal of reference modifiers. More...
struct  blaze::RemoveVolatile< T >
 Removal of volatile-qualifiers. More...

Typedefs

template<typename T>
using blaze::MakeComplex_t = typename MakeComplex<T>::Type
 Auxiliary alias declaration for the MakeComplex type trait.
template<typename TL, typename T>
using blaze::Append_t = typename Append<TL,T>::Type
 Auxiliary alias declaration for the Append class template.
template<typename TL, typename T>
using blaze::Erase_t = typename Erase<TL,T>::Type
 Auxiliary alias declaration for the Erase class template.
template<typename TL, typename T>
using blaze::EraseAll_t = typename EraseAll<TL,T>::Type
 Auxiliary alias declaration for the EraseAll class template.
template<typename TL, size_t Index>
using blaze::TypeAt_t = typename TypeAt<TL,Index>::Type
 Auxiliary alias declaration for the TypeAt class template.
template<typename TL>
using blaze::Unique_t = typename Unique<TL>::Type
 Auxiliary alias declaration for the Unique class template.
template<typename T>
using blaze::AddConst_t = typename AddConst<T>::Type
 Auxiliary alias declaration for the AddConst type trait.
template<typename T>
using blaze::AddCV_t = typename AddCV<T>::Type
 Auxiliary alias declaration for the AddCV type trait.
template<typename T>
using blaze::AddLValueReference_t = typename AddLValueReference<T>::Type
 Auxiliary alias declaration for the AddLValueReference type trait.
template<typename T>
using blaze::AddPointer_t = typename AddPointer<T>::Type
 Auxiliary alias declaration for the AddPointer type trait.
template<typename T>
using blaze::AddRValueReference_t = typename AddRValueReference<T>::Type
 Auxiliary alias declaration for the AddRValueReference type trait.
template<typename T>
using blaze::AddVolatile_t = typename AddVolatile<T>::Type
 Auxiliary alias declaration for the AddVolatile type trait.
template<typename... T>
using blaze::CommonType_t = typename CommonType<T...>::Type
 Auxiliary alias declaration for the CommonType type trait.
template<typename T>
using blaze::Decay_t = typename Decay<T>::Type
 Auxiliary alias declaration for the Decay type trait.
template<typename T1, typename T2>
using blaze::GreaterThan_t = decltype( std::declval<T1>() > std::declval<T2>() )
 Auxiliary type alias for the HasGreaterThan type trait.
template<typename T1, typename T2>
using blaze::HasGreaterThan = IsDetected< GreaterThan_t, T1, T2 >
 Compile time check for the availability of a greater-than operation between two data types.
template<typename T1, typename T2>
using blaze::LessThan_t = decltype( std::declval<T1>() < std::declval<T2>() )
 Auxiliary type alias for the HasLessThan type trait.
template<typename T1, typename T2>
using blaze::HasLessThan = IsDetected< LessThan_t, T1, T2 >
 Compile time check for the availability of a less-than operation between two data types.
template<typename Default, template< typename... > class OP, typename... Ts>
using blaze::DetectedOr = Detector<Default,void,OP,Ts...>
 Compile time detection of type properties.
template<template< typename... > class OP, typename... Ts>
using blaze::IsDetected = typename DetectedOr<NoneSuch,OP,Ts...>::Value_t
 Compile time detection of type properties.
template<template< typename... > class OP, typename... Ts>
using blaze::Detected_t = typename DetectedOr<NoneSuch,OP,Ts...>::Type
 Compile time detection of type properties.
template<typename Default, template< typename... > class OP, typename... Ts>
using blaze::DetectedOr_t = typename DetectedOr<Default,OP,Ts...>::Type
 Auxiliary variable template for the DetectedOr type trait.
template<typename T>
using blaze::MakeSigned_t = typename MakeSigned<T>::Type
 Auxiliary alias declaration for the MakeSigned type trait.
template<typename T>
using blaze::MakeUnsigned_t = typename MakeUnsigned<T>::Type
 Auxiliary alias declaration for the MakeUnsigned type trait.
template<typename T>
using blaze::RemoveAllExtents_t = typename RemoveAllExtents<T>::Type
 Auxiliary alias declaration for the RemoveAllExtents type trait.
template<typename T>
using blaze::RemoveConst_t = typename RemoveConst<T>::Type
 Auxiliary alias declaration for the RemoveConst type trait.
template<typename T>
using blaze::RemoveCV_t = typename RemoveCV<T>::Type
 Auxiliary alias declaration for the RemoveCV type trait.
template<typename T>
using blaze::RemoveCVRef_t = typename RemoveCVRef<T>::Type
 Auxiliary alias declaration for the RemoveCVRef type trait.
template<typename T>
using blaze::RemoveExtent_t = typename RemoveExtent<T>::Type
 Auxiliary alias declaration for the RemoveExtent type trait.
template<typename T>
using blaze::RemoveLValueReference_t = typename RemoveLValueReference<T>::Type
 Auxiliary alias declaration for the RemoveLValueReference type trait.
template<typename T>
using blaze::RemovePointer_t = typename RemovePointer<T>::Type
 Auxiliary alias declaration for the RemovePointer type trait.
template<typename T>
using blaze::RemoveReference_t = typename RemoveReference<T>::Type
 Auxiliary alias declaration for the RemoveReference type trait.
template<typename T>
using blaze::RemoveRValueReference_t = typename RemoveRValueReference<T>::Type
 Auxiliary alias declaration for the RemoveRValueReference type trait.
template<typename T>
using blaze::RemoveVolatile_t = typename RemoveVolatile<T>::Type
 Auxiliary alias declaration for the RemoveVolatile type trait.
template<typename... Ts>
using blaze::Void_t = void
 Compile time type check.

Variables

template<typename T>
constexpr bool blaze::IsCUDAAssignable_v = IsCUDAAssignable<T>::value
 Auxiliary variable template for the IsCUDAAssignable type trait.
template<typename TL, typename T>
constexpr bool blaze::Contains_v = Contains<TL,T>::value
 Auxiliary variable template for the Contains type trait.
template<typename TL, typename T>
constexpr bool blaze::ContainsRelated_v = ContainsRelated<TL,T>::value
 Auxiliary variable template for the ContainsRelated type trait.
template<typename TL, typename T>
constexpr size_t blaze::IndexOf_v = IndexOf<TL,T>::value
 Auxiliary variable template for the IndexOf type trait.
template<typename TL>
constexpr size_t blaze::Length_v = Length<TL>::value
 Auxiliary variable template for the Length type trait.
template<typename T>
constexpr size_t blaze::AlignmentOf_v = AlignmentOf<T>::value
 Auxiliary variable template for the AlignmentOf type trait.
template<template< typename > class TypeTrait, typename T1, typename T2, typename... Ts>
constexpr bool blaze::All_v = All<TypeTrait,T1,T2,Ts...>::value
 Auxiliary variable template for the All type trait.
template<typename T>
constexpr bool blaze::AlwaysFalse_v = false
 Auxiliary variable template for the AlwaysFalse type trait.
template<typename T>
constexpr bool blaze::AlwaysTrue_v = true
 Auxiliary variable template for the AlwaysTrue type trait.
template<template< typename > class TypeTrait, typename T1, typename T2, typename... Ts>
constexpr bool blaze::Any_v = Any<TypeTrait,T1,T2,Ts...>::value
 Auxiliary variable template for the Any type trait.
template<typename T, size_t N>
constexpr size_t blaze::Extent_v = Extent<T,N>::value
 Auxiliary variable template for the Extent type trait.
template<typename T1, typename T2>
constexpr bool blaze::HasGreaterThan_v = HasGreaterThan<T1,T2>::value
 Auxiliary variable template for the HasGreaterThan type trait.
template<typename T1, typename T2>
constexpr bool blaze::HasLessThan_v = HasLessThan<T1,T2>::value
 Auxiliary variable template for the HasLessThan type trait.
template<typename T, size_t S>
constexpr bool blaze::HasSize_v = HasSize<T,S>::value
 Auxiliary variable template for the HasSize type trait.
template<typename T>
constexpr bool blaze::Has1Byte_v = Has1Byte<T>::value
 Auxiliary variable template for the Has1Byte type trait.
template<typename T>
constexpr bool blaze::Has2Bytes_v = Has2Bytes<T>::value
 Auxiliary variable template for the Has2Bytes type trait.
template<typename T>
constexpr bool blaze::Has4Bytes_v = Has4Bytes<T>::value
 Auxiliary variable template for the Has4Bytes type trait.
template<typename T>
constexpr bool blaze::Has8Bytes_v = Has8Bytes<T>::value
 Auxiliary variable template for the Has8Bytes type trait.
template<typename T1, typename T2>
constexpr bool blaze::HaveSameSize_v = HaveSameSize<T1,T2>::value
 Auxiliary variable template for the HaveSameSize type trait.
template<typename T>
constexpr bool blaze::IsArithmetic_v = IsArithmetic<T>::value
 Auxiliary variable template for the IsArithmetic type trait.
template<typename T>
constexpr bool blaze::IsArray_v = IsArray<T>::value
 Auxiliary variable template for the IsArray type trait.
template<typename T, typename U>
constexpr bool blaze::IsAssignable_v = IsAssignable<T,U>::value
 Auxiliary variable template for the IsAssignable type trait.
template<typename T, typename U>
constexpr bool blaze::IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value
 Auxiliary variable template for the IsNothrowAssignable type trait.
template<typename T>
constexpr bool blaze::IsCopyAssignable_v = IsCopyAssignable<T>::value
 Auxiliary variable template for the IsCopyAssignable type trait.
template<typename T>
constexpr bool blaze::IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value
 Auxiliary variable template for the IsNothrowCopyAssignable type trait.
template<typename T>
constexpr bool blaze::IsMoveAssignable_v = IsMoveAssignable<T>::value
 Auxiliary variable template for the IsMoveAssignable type trait.
template<typename T>
constexpr bool blaze::IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value
 Auxiliary variable template for the IsNothrowMoveAssignable type trait.
template<typename Base, typename Derived>
constexpr bool blaze::IsBaseOf_v = IsBaseOf<Base,Derived>::value
 Auxiliary variable template for the IsBaseOf type trait.
template<typename T>
constexpr bool blaze::IsBoolean_v = IsBoolean<T>::value
 Auxiliary variable template for the IsBoolean type trait.
template<typename T>
constexpr bool blaze::IsBuiltin_v = IsBuiltin<T>::value
 Auxiliary variable template for the IsBuiltin type trait.
template<typename T>
constexpr bool blaze::IsCharacter_v = IsCharacter<T>::value
 Auxiliary variable template for the IsCharacter type trait.
template<typename T>
constexpr bool blaze::IsClass_v = IsClass<T>::value
 Auxiliary variable template for the IsClass type trait.
template<typename T>
constexpr bool blaze::IsComplex_v = IsComplex<T>::value
 Auxiliary variable template for the IsComplex type trait.
template<typename T>
constexpr bool blaze::IsComplexDouble_v = IsComplexDouble<T>::value
 Auxiliary variable template for the IsComplexDouble type trait.
template<typename T>
constexpr bool blaze::IsComplexFloat_v = IsComplexFloat<T>::value
 Auxiliary variable template for the IsComplexFloat type trait.
template<typename T>
constexpr bool blaze::IsConst_v = IsConst<T>::value
 Auxiliary variable template for the IsConst type trait.
template<typename T, typename... Args>
constexpr bool blaze::IsConstructible_v = IsConstructible<T>::value
 Auxiliary variable template for the IsConstructible type trait.
template<typename T, typename... Args>
constexpr bool blaze::IsNothrowConstructible_v = IsNothrowConstructible<T>::value
 Auxiliary variable template for the IsNothrowConstructible type trait.
template<typename T>
constexpr bool blaze::IsDefaultConstructible_v = IsDefaultConstructible<T>::value
 Auxiliary variable template for the IsDefaultConstructible type trait.
template<typename T>
constexpr bool blaze::IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value
 Auxiliary variable template for the IsNothrowDefaultConstructible type trait.
template<typename T>
constexpr bool blaze::IsCopyConstructible_v = IsCopyConstructible<T>::value
 Auxiliary variable template for the IsCopyConstructible type trait.
template<typename T>
constexpr bool blaze::IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value
 Auxiliary variable template for the IsNothrowCopyConstructible type trait.
template<typename T>
constexpr bool blaze::IsMoveConstructible_v = IsMoveConstructible<T>::value
 Auxiliary variable template for the IsMoveConstructible type trait.
template<typename T>
constexpr bool blaze::IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value
 Auxiliary variable template for the IsNothrowMoveConstructible type trait.
template<typename From, typename To>
constexpr bool blaze::IsConvertible_v = IsConvertible<From,To>::value
 Auxiliary variable template for the IsConvertible type trait.
template<typename T>
constexpr bool blaze::IsDestructible_v = IsDestructible<T>::value
 Auxiliary variable template for the IsDestructible type trait.
template<typename T>
constexpr bool blaze::IsNothrowDestructible_v = IsNothrowDestructible<T>::value
 Auxiliary variable template for the IsNothrowDestructible type trait.
template<template< typename... > class OP, typename... Ts>
constexpr bool blaze::IsDetected_v = IsDetected<OP,Ts...>::value
 Auxiliary variable template for the IsDetected type trait.
template<typename T>
constexpr bool blaze::IsDouble_v = IsDouble<T>::value
 Auxiliary variable template for the IsDouble type trait.
template<typename T>
constexpr bool blaze::IsEmpty_v = IsEmpty<T>::value
 Auxiliary variable template for the IsEmpty type trait.
template<typename T>
constexpr bool blaze::IsEnum_v = IsEnum<T>::value
 Auxiliary variable template for the IsEnum type trait.
template<typename T>
constexpr bool blaze::IsFloat_v = IsFloat<T>::value
 Auxiliary variable template for the IsFloat type trait.
template<typename T>
constexpr bool blaze::IsFloatingPoint_v = IsFloatingPoint<T>::value
 Auxiliary variable template for the IsFloatingPoint type trait.
template<typename T>
constexpr bool blaze::IsInteger_v = IsInteger<T>::value
 Auxiliary variable template for the IsInteger type trait.
template<typename T>
constexpr bool blaze::IsIntegral_v = IsIntegral<T>::value
 Auxiliary variable template for the IsIntegral type trait.
template<typename T>
constexpr bool blaze::IsLong_v = IsLong<T>::value
 Auxiliary variable template for the IsLong type trait.
template<typename T>
constexpr bool blaze::IsLongDouble_v = IsLongDouble<T>::value
 Auxiliary variable template for the IsLongDouble type trait.
template<typename T>
constexpr bool blaze::IsLValueReference_v = IsLValueReference<T>::value
 Auxiliary variable template for the IsLValueReference type trait.
template<typename T>
constexpr bool blaze::IsNumeric_v = IsNumeric<T>::value
 Auxiliary variable template for the IsNumeric type trait.
template<typename T>
constexpr bool blaze::IsObject_v = IsObject<T>::value
 Auxiliary variable template for the IsObject type trait.
template<typename T>
constexpr bool blaze::IsPod_v = IsPod<T>::value
 Auxiliary variable template for the IsPod type trait.
template<typename T>
constexpr bool blaze::IsPointer_v = IsPointer<T>::value
 Auxiliary variable template for the IsPointer type trait.
template<typename T>
constexpr bool blaze::IsReference_v = IsReference<T>::value
 Auxiliary variable template for the IsReference type trait.
template<typename T>
constexpr bool blaze::IsRValueReference_v = IsRValueReference<T>::value
 Auxiliary variable template for the IsRValueReference type trait.
template<typename A, typename B>
constexpr bool blaze::IsStrictlySame_v = IsStrictlySame<A,B>::value
 Auxiliary variable template for the IsStrictlySame type trait.
template<typename A, typename B>
constexpr bool blaze::IsSame_v = IsSame<A,B>::value
 Auxiliary variable template for the IsSame type trait.
template<typename T>
constexpr bool blaze::IsShort_v = IsShort<T>::value
 Auxiliary variable template for the IsShort type trait.
template<typename T>
constexpr bool blaze::IsSigned_v = IsSigned<T>::value
 Auxiliary variable template for the IsSigned type trait.
template<typename T>
constexpr bool blaze::IsUnion_v = IsUnion<T>::value
 Auxiliary variable template for the IsUnion type trait.
template<typename T>
constexpr bool blaze::IsUnsigned_v = IsUnsigned<T>::value
 Auxiliary variable template for the IsUnsigned type trait.
template<typename T>
constexpr bool blaze::IsValid_v = IsValid<T>::value
 Auxiliary variable template for the IsValid type trait.
template<typename T>
constexpr bool blaze::IsVectorizable_v = IsVectorizable<T>::value
 Auxiliary variable template for the IsVectorizable type trait.
template<typename T>
constexpr bool blaze::IsVoid_v = IsVoid<T>::value
 Auxiliary variable template for the IsVoid type trait.
template<typename T>
constexpr bool blaze::IsVolatile_v = IsVolatile<T>::value
 Auxiliary variable template for the IsVolatile type trait.
template<typename T>
constexpr size_t blaze::Rank_v = Rank<T>::value
 Auxiliary variable template for the Rank type trait.

Detailed Description

Typedef Documentation

◆ AddConst_t

template<typename T>
using blaze::AddConst_t = typename AddConst<T>::Type

Auxiliary alias declaration for the AddConst type trait.

The AddConst_t 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 blaze::AddConst<T>::Type;
using Type2 = blaze::AddConst_t<T>;
typename AddConst< T >::Type AddConst_t
Auxiliary alias declaration for the AddConst type trait.
Definition AddConst.h:95
Addition of a top level 'const' qualifier.
Definition AddConst.h:70

◆ AddCV_t

template<typename T>
using blaze::AddCV_t = typename AddCV<T>::Type

Auxiliary alias declaration for the AddCV type trait.

The AddCV_t 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 blaze::AddCV<T>::Type;
using Type2 = blaze::AddCV_t<T>;
typename AddCV< T >::Type AddCV_t
Auxiliary alias declaration for the AddCV type trait.
Definition AddCV.h:96
Addition of a top level 'const' and 'volatile' qualifier.
Definition AddCV.h:71

◆ AddLValueReference_t

template<typename T>
using blaze::AddLValueReference_t = typename AddLValueReference<T>::Type

Auxiliary alias declaration for the AddLValueReference type trait.

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

using Type1 = typename blaze::AddLValueReference<T>::Type;
typename AddLValueReference< T >::Type AddLValueReference_t
Auxiliary alias declaration for the AddLValueReference type trait.
Definition AddLValueReference.h:97
Addition of a top level reference.
Definition AddLValueReference.h:72

◆ AddPointer_t

template<typename T>
using blaze::AddPointer_t = typename AddPointer<T>::Type

Auxiliary alias declaration for the AddPointer type trait.

The AddPointer_t 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 blaze::AddPointer<T>::Type;
using Type2 = blaze::AddPointer_t<T>;
typename AddPointer< T >::Type AddPointer_t
Auxiliary alias declaration for the AddPointer type trait.
Definition AddPointer.h:95
Addition of a top level pointer.
Definition AddPointer.h:70

◆ AddRValueReference_t

template<typename T>
using blaze::AddRValueReference_t = typename AddRValueReference<T>::Type

Auxiliary alias declaration for the AddRValueReference type trait.

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

using Type1 = typename blaze::AddRValueReference<T>::Type;
typename AddRValueReference< T >::Type AddRValueReference_t
Auxiliary alias declaration for the AddRValueReference type trait.
Definition AddRValueReference.h:95
Addition of a top level reference.
Definition AddRValueReference.h:70

◆ AddVolatile_t

template<typename T>
using blaze::AddVolatile_t = typename AddVolatile<T>::Type

Auxiliary alias declaration for the AddVolatile type trait.

The AddVolatile_t 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 blaze::AddVolatile<T>::Type;
typename AddVolatile< T >::Type AddVolatile_t
Auxiliary alias declaration for the AddVolatile type trait.
Definition AddVolatile.h:95
Addition of a top level 'volatile' qualifier.
Definition AddVolatile.h:70

◆ Append_t

template<typename TL, typename T>
using blaze::Append_t = typename Append<TL,T>::Type

Auxiliary alias declaration for the Append class template.

The Append_t alias declaration provides a convenient shortcut to access the nested Type of the Append class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename Append<TL,T>::Type;
using Type2 = Append_t<TL,T>;
typename Append< TL, T >::Type Append_t
Auxiliary alias declaration for the Append class template.
Definition Append.h:118
Appending a type to a type list.
Definition Append.h:69

◆ CommonType_t

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

Auxiliary alias declaration for the CommonType type trait.

The CommonType_t 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 blaze::CommonType<T1,T2>::Type;
typename CommonType< T... >::Type CommonType_t
Auxiliary alias declaration for the CommonType type trait.
Definition CommonType.h:95
Deduction of a type common to several types.
Definition CommonType.h:70

◆ Decay_t

template<typename T>
using blaze::Decay_t = typename Decay<T>::Type

Auxiliary alias declaration for the Decay type trait.

The Decay_t 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 blaze::Decay<T>::Type;
using Type2 = blaze::Decay_t<T>;
typename Decay< T >::Type Decay_t
Auxiliary alias declaration for the Decay type trait.
Definition Decay.h:98
Applies the type conversions for by-value function arguments.
Definition Decay.h:73

◆ Detected_t

template<template< typename... > class OP, typename... Ts>
using blaze::Detected_t = typename DetectedOr<NoneSuch,OP,Ts...>::Type

Compile time detection of type properties.

The Detected_t type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, DetectedOr evaluates to OP<Ts...>. Otherwise it evaluates to NoneSuch.

template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
static_assert( IsSame_v< Detected_t<Diff_t, C>, int > , "C's difference_type should be int!" );
static_assert( IsSame_v< Detected_t<Diff_t, D>, NoneSuch >, "D should not have a difference type!");
constexpr bool IsSame_v
Auxiliary variable template for the IsSame type trait.
Definition IsSame.h:159
Default result type for the Detected_t type trait.
Definition IsDetected.h:59

◆ DetectedOr

template<typename Default, template< typename... > class OP, typename... Ts>
using blaze::DetectedOr = Detector<Default,void,OP,Ts...>

Compile time detection of type properties.

The DetectedOr type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, Detected_t evaluates to OP<Ts...>. Otherwise it evaluates to Default.

template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
template< typename T >
using difference_type = typename DetectedOr<ptrdiff_t, Diff_t, T>::Type;
static_assert( IsSame_v< difference_type<C>, int > , "C's difference_type should be int!" );
static_assert( IsSame_v< difference_type<D>, ptrdiff_t >, "D's difference_type should be ptrdiff_t!");
Detector< Default, void, OP, Ts... > DetectedOr
Compile time detection of type properties.
Definition IsDetected.h:116

◆ DetectedOr_t

template<typename Default, template< typename... > class OP, typename... Ts>
using blaze::DetectedOr_t = typename DetectedOr<Default,OP,Ts...>::Type

Auxiliary variable template for the DetectedOr type trait.

The DetectedOr_t variable template provides a convenient shortcut to access the nested Type of the DetectedOr class template. For instance, given the type Default, the template OP and the two types T1 and T2 the following two statements are identical:

typename DetectedOr< Default, OP, Ts... >::Type DetectedOr_t
Auxiliary variable template for the DetectedOr type trait.
Definition IsDetected.h:211

◆ Erase_t

template<typename TL, typename T>
using blaze::Erase_t = typename Erase<TL,T>::Type

Auxiliary alias declaration for the Erase class template.

The Erase_t alias declaration provides a convenient shortcut to access the nested Type of the Erase class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename Erase<TL,T>::Type;
using Type2 = Erase_t<TL,T>;
typename Erase< TL, T >::Type Erase_t
Auxiliary alias declaration for the Erase class template.
Definition Erase.h:138
Erasing the first occurrence of a type from a type list.
Definition Erase.h:74

◆ EraseAll_t

template<typename TL, typename T>
using blaze::EraseAll_t = typename EraseAll<TL,T>::Type

Auxiliary alias declaration for the EraseAll class template.

The EraseAll_t alias declaration provides a convenient shortcut to access the nested Type of the EraseAll class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename EraseAll<TL,T>::Type;
using Type2 = EraseAll_t<TL,T>;
typename EraseAll< TL, T >::Type EraseAll_t
Auxiliary alias declaration for the EraseAll class template.
Definition EraseAll.h:138
Erasing all occurrences of a type from a type list.
Definition EraseAll.h:74

◆ HasGreaterThan

template<typename T1, typename T2>
using blaze::HasGreaterThan = IsDetected< GreaterThan_t, T1, T2 >

Compile time check for the availability of a greater-than operation between two data types.

This type trait determines whether the given data types T1 and T2 can be used in a greater-than operation. If the operation is available, 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.

blaze::HasGreaterThan< int*, std::string* > // Is derived from FalseType
IsDetected< GreaterThan_t, T1, T2 > HasGreaterThan
Compile time check for the availability of a greater-than operation between two data types.
Definition HasGreaterThan.h:84

◆ HasLessThan

template<typename T1, typename T2>
using blaze::HasLessThan = IsDetected< LessThan_t, T1, T2 >

Compile time check for the availability of a less-than operation between two data types.

This type trait determines whether the given data types T1 and T2 can be used in a less-than operation. If the operation is available, 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.

blaze::HasLessThan< volatile int*, int* > // Is derived from TrueType
blaze::HasLessThan< int*, std::string* > // Is derived from FalseType
IsDetected< LessThan_t, T1, T2 > HasLessThan
Compile time check for the availability of a less-than operation between two data types.
Definition HasLessThan.h:84

◆ IsDetected

template<template< typename... > class OP, typename... Ts>
using blaze::IsDetected = typename DetectedOr<NoneSuch,OP,Ts...>::Value_t

Compile time detection of type properties.

The IsDetected type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, IsDetected is an alias for TrueType. Otherwise it is an alias for FalseType.

template<class T>
using CopyAssign_t = decltype( std::declval<T&>() = std::declval<const T&>() );
struct A { };
struct B { void operator=( const B& ) = delete; };
static_assert( IsDetected_v<CopyAssign_t, A> , "A should be copy assignable!" );
static_assert( !IsDetected_v<CopyAssign_t, B>, "B should not be copy assignable!");
constexpr bool IsDetected_v
Auxiliary variable template for the IsDetected type trait.
Definition IsDetected.h:193
template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
static_assert( IsDetected_v<Diff_t, C> , "C should have a difference type!" );
static_assert( !IsDetected_v<Diff_t, D>, "D should not have a difference type!");

◆ MakeComplex_t

template<typename T>
using blaze::MakeComplex_t = typename MakeComplex<T>::Type

Auxiliary alias declaration for the MakeComplex type trait.

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

using Type1 = typename blaze::MakeComplex<T>::Type;
typename MakeComplex< T >::Type MakeComplex_t
Auxiliary alias declaration for the MakeComplex type trait.
Definition MakeComplex.h:204
Converting the given type to the matching 'complex' type.
Definition MakeComplex.h:74

◆ MakeSigned_t

template<typename T>
using blaze::MakeSigned_t = typename MakeSigned<T>::Type

Auxiliary alias declaration for the MakeSigned type trait.

The MakeSigned_t 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 blaze::MakeSigned<T>::Type;
using Type2 = blaze::MakeSigned_t<T>;
typename MakeSigned< T >::Type MakeSigned_t
Auxiliary alias declaration for the MakeSigned type trait.
Definition MakeSigned.h:99
Compile time type conversion into a signed integral type.
Definition MakeSigned.h:74

◆ MakeUnsigned_t

template<typename T>
using blaze::MakeUnsigned_t = typename MakeUnsigned<T>::Type

Auxiliary alias declaration for the MakeUnsigned type trait.

The MakeUnsigned_t 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 blaze::MakeUnsigned<T>::Type;
typename MakeUnsigned< T >::Type MakeUnsigned_t
Auxiliary alias declaration for the MakeUnsigned type trait.
Definition MakeUnsigned.h:99
Compile time type conversion into an unsigned integral type.
Definition MakeUnsigned.h:74

◆ RemoveAllExtents_t

template<typename T>
using blaze::RemoveAllExtents_t = typename RemoveAllExtents<T>::Type

Auxiliary alias declaration for the RemoveAllExtents type trait.

The RemoveAllExtents_t 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 blaze::RemoveAllExtents<T>::Type;
typename RemoveAllExtents< T >::Type RemoveAllExtents_t
Auxiliary alias declaration for the RemoveAllExtents type trait.
Definition RemoveAllExtents.h:96
Removal of all array extents.
Definition RemoveAllExtents.h:71

◆ RemoveConst_t

template<typename T>
using blaze::RemoveConst_t = typename RemoveConst<T>::Type

Auxiliary alias declaration for the RemoveConst type trait.

The RemoveConst_t 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 blaze::RemoveConst<T>::Type;
typename RemoveConst< T >::Type RemoveConst_t
Auxiliary alias declaration for the RemoveConst type trait.
Definition RemoveConst.h:96
Removal of const-qualifiers.
Definition RemoveConst.h:71

◆ RemoveCV_t

template<typename T>
using blaze::RemoveCV_t = typename RemoveCV<T>::Type

Auxiliary alias declaration for the RemoveCV type trait.

The RemoveCV_t 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 blaze::RemoveCV<T>::Type;
using Type2 = blaze::RemoveCV_t<T>;
typename RemoveCV< T >::Type RemoveCV_t
Auxiliary alias declaration for the RemoveCV type trait.
Definition RemoveCV.h:97
Removal of top level cv-qualifiers.
Definition RemoveCV.h:72

◆ RemoveCVRef_t

template<typename T>
using blaze::RemoveCVRef_t = typename RemoveCVRef<T>::Type

Auxiliary alias declaration for the RemoveCVRef type trait.

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

using Type1 = typename blaze::RemoveCVRef<T>::Type;
typename RemoveCVRef< T >::Type RemoveCVRef_t
Auxiliary alias declaration for the RemoveCVRef type trait.
Definition RemoveCVRef.h:99
Removal of top level cv-qualifiers.
Definition RemoveCVRef.h:74

◆ RemoveExtent_t

template<typename T>
using blaze::RemoveExtent_t = typename RemoveExtent<T>::Type

Auxiliary alias declaration for the RemoveExtent type trait.

The RemoveExtent_t 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 blaze::RemoveExtent<T>::Type;
typename RemoveExtent< T >::Type RemoveExtent_t
Auxiliary alias declaration for the RemoveExtent type trait.
Definition RemoveExtent.h:95
Removal of the top level array extent.
Definition RemoveExtent.h:70

◆ RemoveLValueReference_t

template<typename T>
using blaze::RemoveLValueReference_t = typename RemoveLValueReference<T>::Type

Auxiliary alias declaration for the RemoveLValueReference type trait.

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

typename RemoveLValueReference< T >::Type RemoveLValueReference_t
Auxiliary alias declaration for the RemoveLValueReference type trait.
Definition RemoveLValueReference.h:105
Removal of reference modifiers.
Definition RemoveLValueReference.h:65

◆ RemovePointer_t

template<typename T>
using blaze::RemovePointer_t = typename RemovePointer<T>::Type

Auxiliary alias declaration for the RemovePointer type trait.

The RemovePointer_t 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 blaze::RemovePointer<T>::Type;
typename RemovePointer< T >::Type RemovePointer_t
Auxiliary alias declaration for the RemovePointer type trait.
Definition RemovePointer.h:95
Removal of pointer modifiers.
Definition RemovePointer.h:70

◆ RemoveReference_t

template<typename T>
using blaze::RemoveReference_t = typename RemoveReference<T>::Type

Auxiliary alias declaration for the RemoveReference type trait.

The RemoveReference_t 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 blaze::RemoveReference<T>::Type;
typename RemoveReference< T >::Type RemoveReference_t
Auxiliary alias declaration for the RemoveReference type trait.
Definition RemoveReference.h:95
Removal of reference modifiers.
Definition RemoveReference.h:70

◆ RemoveRValueReference_t

template<typename T>
using blaze::RemoveRValueReference_t = typename RemoveRValueReference<T>::Type

Auxiliary alias declaration for the RemoveRValueReference type trait.

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

typename RemoveRValueReference< T >::Type RemoveRValueReference_t
Auxiliary alias declaration for the RemoveRValueReference type trait.
Definition RemoveRValueReference.h:105
Removal of reference modifiers.
Definition RemoveRValueReference.h:65

◆ RemoveVolatile_t

template<typename T>
using blaze::RemoveVolatile_t = typename RemoveVolatile<T>::Type

Auxiliary alias declaration for the RemoveVolatile type trait.

The RemoveVolatile_t 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 blaze::RemoveVolatile<T>::Type;
typename RemoveVolatile< T >::Type RemoveVolatile_t
Auxiliary alias declaration for the RemoveVolatile type trait.
Definition RemoveVolatile.h:97
Removal of volatile-qualifiers.
Definition RemoveVolatile.h:72

◆ TypeAt_t

template<typename TL, size_t Index>
using blaze::TypeAt_t = typename TypeAt<TL,Index>::Type

Auxiliary alias declaration for the TypeAt class template.

The TypeAt_t alias declaration provides a convenient shortcut to access the nested Type of the TypeAt class template. For instance, given the type list TL and the index Index the following two type definitions are identical:

using Type1 = typename TypeAt<TL,Index>::Type;
using Type2 = TypeAt_t<TL,Index>;
typename TypeAt< TL, Index >::Type TypeAt_t
Auxiliary alias declaration for the TypeAt class template.
Definition TypeAt.h:139
Indexing a type list.
Definition TypeAt.h:75

◆ Unique_t

template<typename TL>
using blaze::Unique_t = typename Unique<TL>::Type

Auxiliary alias declaration for the Unique class template.

The Unique_t alias declaration provides a convenient shortcut to access the nested Type of the Unique class template. For instance, given the type list TL the following two type definitions are identical:

using Type1 = typename Unique<TL>::Type;
using Type2 = Unique_t<TL>;
typename Unique< TL >::Type Unique_t
Auxiliary alias declaration for the Unique class template.
Definition Unique.h:125
Erasing all duplicates from a type list.
Definition Unique.h:73

◆ Void_t

template<typename... Ts>
using blaze::Void_t = 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_t<> >
struct HasAdd : public FalseType {};
template< typename T1, typename T2
, Void_t< decltype( std::declval<T1>() + std::declval<T2>() ) >
struct HasAdd : public TrueType {};
void Void_t
Compile time type check.
Definition Void.h:64
BoolConstant< false > FalseType
Type/value traits base class.
Definition IntegralConstant.h:121
BoolConstant< true > TrueType
Type traits base class.
Definition IntegralConstant.h:132
Availability of an addition operator for the given data types.
Definition HasAdd.h:107

Variable Documentation

◆ AlignmentOf_v

template<typename T>
size_t blaze::AlignmentOf_v = AlignmentOf<T>::value
constexpr

Auxiliary variable template for the AlignmentOf type trait.

The AlignmentOf_v variable template provides a convenient shortcut to access the nested value of the AlignmentOf class template. For instance, given the type T the following two statements are identical:

constexpr size_t value1 = blaze::AlignmentOf<T>::value;
constexpr size_t value2 = blaze::AlignmentOf_v<T>;
constexpr size_t AlignmentOf_v
Auxiliary variable template for the AlignmentOf type trait.
Definition AlignmentOf.h:239
Evaluation of the required alignment of the given data type.
Definition AlignmentOf.h:182

◆ All_v

template<template< typename > class TypeTrait, typename T1, typename T2, typename... Ts>
bool blaze::All_v = All<TypeTrait,T1,T2,Ts...>::value
constexpr

Auxiliary variable template for the All type trait.

The All_v variable template provides a convenient shortcut to access the nested value of the All class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::All<TypeTrait,T1,T2>::value;
constexpr bool value2 = blaze::All_v<TypeTrait,T1,T2>;
constexpr bool All_v
Auxiliary variable template for the All type trait.
Definition All.h:106
Compile time type check.
Definition All.h:85

◆ AlwaysFalse_v

template<typename T>
bool blaze::AlwaysFalse_v = false
constexpr

Auxiliary variable template for the AlwaysFalse type trait.

The AlwaysFalse_v variable template provides a convenient shortcut to access the nested value of the AlwaysFalse class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::AlwaysFalse<T>::value;
constexpr bool value2 = blaze::AlwaysFalse_v<T>;
constexpr bool AlwaysFalse_v
Auxiliary variable template for the AlwaysFalse type trait.
Definition AlwaysFalse.h:83
Type dependent compile time false.
Definition AlwaysFalse.h:65

◆ AlwaysTrue_v

template<typename T>
bool blaze::AlwaysTrue_v = true
constexpr

Auxiliary variable template for the AlwaysTrue type trait.

The AlwaysTrue_v variable template provides a convenient shortcut to access the nested value of the AlwaysTrue class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::AlwaysTrue<T>::value;
constexpr bool value2 = blaze::AlwaysTrue_v<T>;
constexpr bool AlwaysTrue_v
Auxiliary variable template for the AlwaysTrue type trait.
Definition AlwaysTrue.h:83
Type dependent compile time true.
Definition AlwaysTrue.h:65

◆ Any_v

template<template< typename > class TypeTrait, typename T1, typename T2, typename... Ts>
bool blaze::Any_v = Any<TypeTrait,T1,T2,Ts...>::value
constexpr

Auxiliary variable template for the Any type trait.

The Any_v variable template provides a convenient shortcut to access the nested value of the Any class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::Any<TypeTrait,T1,T2>::value;
constexpr bool value2 = blaze::Any_v<TypeTrait,T1,T2>;
constexpr bool Any_v
Auxiliary variable template for the Any type trait.
Definition Any.h:106
Compile time type check.
Definition Any.h:85

◆ Contains_v

template<typename TL, typename T>
bool blaze::Contains_v = Contains<TL,T>::value
constexpr

Auxiliary variable template for the Contains type trait.

The Contains_v variable template provides a convenient shortcut to access the nested value of the Contains class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr bool value1 = Contains<TL,T>::value;
constexpr bool value2 = Contains_v<TL,T>;
constexpr bool Contains_v
Auxiliary variable template for the Contains type trait.
Definition Contains.h:138
Searching a type list.
Definition Contains.h:77

◆ ContainsRelated_v

template<typename TL, typename T>
bool blaze::ContainsRelated_v = ContainsRelated<TL,T>::value
constexpr

Auxiliary variable template for the ContainsRelated type trait.

The ContainsRelated_v variable template provides a convenient shortcut to access the nested value of the ContainsRelated class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr bool value1 = ContainsRelated<TL,T>::value;
constexpr bool value2 = ContainsRelated_v<TL,T>;
constexpr bool ContainsRelated_v
Auxiliary variable template for the ContainsRelated type trait.
Definition ContainsRelated.h:139
Searching a type list.
Definition ContainsRelated.h:90

◆ Extent_v

template<typename T, size_t N>
size_t blaze::Extent_v = Extent<T,N>::value
constexpr

Auxiliary variable template for the Extent type trait.

The Extent_v variable template provides a convenient shortcut to access the nested value of the Extent class template. For instance, given the type T and the compile time constant N the following two statements are identical:

constexpr size_t value1 = blaze::Extent<T,N>::value;
constexpr size_t value2 = blaze::Extent_v<T,N>;
constexpr size_t Extent_v
Auxiliary variable template for the Extent type trait.
Definition Extent.h:141
Compile time check for the size of array bounds.
Definition Extent.h:79

◆ Has1Byte_v

template<typename T>
bool blaze::Has1Byte_v = Has1Byte<T>::value
constexpr

Auxiliary variable template for the Has1Byte type trait.

The Has1Byte_v variable template provides a convenient shortcut to access the nested value of the Has1Byte class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has1Byte<T>::value;
constexpr bool value2 = blaze::Has1Byte_v<T>;
constexpr bool Has1Byte_v
Auxiliary variable template for the Has1Byte type trait.
Definition HasSize.h:223
Compile time size check.
Definition HasSize.h:205

◆ Has2Bytes_v

template<typename T>
bool blaze::Has2Bytes_v = Has2Bytes<T>::value
constexpr

Auxiliary variable template for the Has2Bytes type trait.

The Has2Bytes_v variable template provides a convenient shortcut to access the nested value of the Has2Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has2Bytes<T>::value;
constexpr bool value2 = blaze::Has2Bytes_v<T>;
constexpr bool Has2Bytes_v
Auxiliary variable template for the Has2Bytes type trait.
Definition HasSize.h:275
Compile time size check.
Definition HasSize.h:257

◆ Has4Bytes_v

template<typename T>
bool blaze::Has4Bytes_v = Has4Bytes<T>::value
constexpr

Auxiliary variable template for the Has4Bytes type trait.

The Has4Bytes_v variable template provides a convenient shortcut to access the nested value of the Has4Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has4Bytes<T>::value;
constexpr bool value2 = blaze::Has4Bytes_v<T>;
constexpr bool Has4Bytes_v
Auxiliary variable template for the Has4Bytes type trait.
Definition HasSize.h:327
Compile time size check.
Definition HasSize.h:309

◆ Has8Bytes_v

template<typename T>
bool blaze::Has8Bytes_v = Has8Bytes<T>::value
constexpr

Auxiliary variable template for the Has8Bytes type trait.

The Has8Bytes_v variable template provides a convenient shortcut to access the nested value of the Has8Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has8Bytes<T>::value;
constexpr bool value2 = blaze::Has8Bytes_v<T>;
constexpr bool Has8Bytes_v
Auxiliary variable template for the Has8Bytes type trait.
Definition HasSize.h:379
Compile time size check.
Definition HasSize.h:361

◆ HasGreaterThan_v

template<typename T1, typename T2>
bool blaze::HasGreaterThan_v = HasGreaterThan<T1,T2>::value
constexpr

Auxiliary variable template for the HasGreaterThan type trait.

The HasGreaterThan_v variable template provides a convenient shortcut to access the nested value of the HasGreaterThan class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasGreaterThan<T1,T2>::value;
constexpr bool value2 = blaze::HasGreaterThan_v<T1,T2>;
constexpr bool HasGreaterThan_v
Auxiliary variable template for the HasGreaterThan type trait.
Definition HasGreaterThan.h:102

◆ HasLessThan_v

template<typename T1, typename T2>
bool blaze::HasLessThan_v = HasLessThan<T1,T2>::value
constexpr

Auxiliary variable template for the HasLessThan type trait.

The HasLessThan_v variable template provides a convenient shortcut to access the nested value of the HasLessThan class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasLessThan<T1,T2>::value;
constexpr bool value2 = blaze::HasLessThan_v<T1,T2>;
constexpr bool HasLessThan_v
Auxiliary variable template for the HasLessThan type trait.
Definition HasLessThan.h:102

◆ HasSize_v

template<typename T, size_t S>
bool blaze::HasSize_v = HasSize<T,S>::value
constexpr

Auxiliary variable template for the HasSize type trait.

The HasSize_v variable template provides a convenient shortcut to access the nested value of the HasSize class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSize<T,8UL>::value;
constexpr bool value2 = blaze::HasSize_v<T,8UL>;
constexpr bool HasSize_v
Auxiliary variable template for the HasSize type trait.
Definition HasSize.h:171
Compile time size check.
Definition HasSize.h:77

◆ HaveSameSize_v

template<typename T1, typename T2>
bool blaze::HaveSameSize_v = HaveSameSize<T1,T2>::value
constexpr

Auxiliary variable template for the HaveSameSize type trait.

The HaveSameSize_v variable template provides a convenient shortcut to access the nested value of the HaveSameSize class template. For instance, given the typew T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HaveSameSize<T1,T2>::value;
constexpr bool value2 = blaze::HaveSameSize_v<T1,T2>;
Compile time size check.
Definition HaveSameSize.h:93
constexpr bool HaveSameSize_v
Auxiliary variable template for the HaveSameSize type trait.
Definition HaveSameSize.h:165

◆ IndexOf_v

template<typename TL, typename T>
size_t blaze::IndexOf_v = IndexOf<TL,T>::value
constexpr

Auxiliary variable template for the IndexOf type trait.

The IndexOf_v variable template provides a convenient shortcut to access the nested value of the IndexOf class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr size_t value1 = IndexOf<TL,T>::value;
constexpr size_t value2 = IndexOf_v<TL,T>;
constexpr size_t IndexOf_v
Auxiliary variable template for the IndexOf type trait.
Definition IndexOf.h:136
Searching a type list.
Definition IndexOf.h:75

◆ IsArithmetic_v

template<typename T>
bool blaze::IsArithmetic_v = IsArithmetic<T>::value
constexpr

Auxiliary variable template for the IsArithmetic type trait.

The IsArithmetic_v variable template provides a convenient shortcut to access the nested value of the IsArithmetic class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsArithmetic<T>::value;
constexpr bool value2 = blaze::IsArithmetic_v<T>;
constexpr bool IsArithmetic_v
Auxiliary variable template for the IsArithmetic type trait.
Definition IsArithmetic.h:98
Compile time check for arithmetic data types.
Definition IsArithmetic.h:80

◆ IsArray_v

template<typename T>
bool blaze::IsArray_v = IsArray<T>::value
constexpr

Auxiliary variable template for the IsArray type trait.

The IsArray_v variable template provides a convenient shortcut to access the nested value of the IsArray class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsArray<T>::value;
constexpr bool value2 = blaze::IsArray_v<T>;
constexpr bool IsArray_v
Auxiliary variable template for the IsArray type trait.
Definition IsArray.h:95
Compile time type check.
Definition IsArray.h:77

◆ IsAssignable_v

template<typename T, typename U>
bool blaze::IsAssignable_v = IsAssignable<T,U>::value
constexpr

Auxiliary variable template for the IsAssignable type trait.

The IsAssignable_v variable template provides a convenient shortcut to access the nested value of the IsAssignable class template. For instance, given the types T and U the following two statements are identical:

constexpr bool value1 = blaze::IsAssignable<T,U>::value;
constexpr bool value2 = blaze::IsAssignable_v<T,U>;
constexpr bool IsAssignable_v
Auxiliary variable template for the IsAssignable type trait.
Definition IsAssignable.h:91
Compile time type check.
Definition IsAssignable.h:73

◆ IsBaseOf_v

template<typename Base, typename Derived>
bool blaze::IsBaseOf_v = IsBaseOf<Base,Derived>::value
constexpr

Auxiliary variable template for the IsBaseOf type trait.

The IsBaseOf_v variable template provides a convenient shortcut to access the nested value of the IsBaseOf class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsBaseOf<T1,T2>::value;
constexpr bool value2 = blaze::IsBaseOf_v<T1,T2>;
Compile time analysis of an inheritance relationship.
Definition IsBaseOf.h:82
constexpr bool IsBaseOf_v
Auxiliary variable template for the IsBaseOf type trait.
Definition IsBaseOf.h:100

◆ IsBoolean_v

template<typename T>
bool blaze::IsBoolean_v = IsBoolean<T>::value
constexpr

Auxiliary variable template for the IsBoolean type trait.

The IsBoolean_v variable template provides a convenient shortcut to access the nested value of the IsBoolean class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBoolean<T>::value;
constexpr bool value2 = blaze::IsBoolean_v<T>;
constexpr bool IsBoolean_v
Auxiliary variable template for the IsBoolean type trait.
Definition IsBoolean.h:138
Compile time check for boolean types.
Definition IsBoolean.h:76

◆ IsBuiltin_v

template<typename T>
bool blaze::IsBuiltin_v = IsBuiltin<T>::value
constexpr

Auxiliary variable template for the IsBuiltin type trait.

The IsBuiltin_v variable template provides a convenient shortcut to access the nested value of the IsBuiltin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBuiltin<T>::value;
constexpr bool value2 = blaze::IsBuiltin_v<T>;
constexpr bool IsBuiltin_v
Auxiliary variable template for the IsBuiltin type trait.
Definition IsBuiltin.h:95
Compile time check for built-in data types.
Definition IsBuiltin.h:77

◆ IsCharacter_v

template<typename T>
bool blaze::IsCharacter_v = IsCharacter<T>::value
constexpr

Auxiliary variable template for the IsCharacter type trait.

The IsCharacter_v variable template provides a convenient shortcut to access the nested value of the IsCharacter class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCharacter<T>::value;
constexpr bool value2 = blaze::IsCharacter_v<T>;
constexpr bool IsCharacter_v
Auxiliary variable template for the IsCharacter type trait.
Definition IsCharacter.h:172
Compile time check for character types.
Definition IsCharacter.h:77

◆ IsClass_v

template<typename T>
bool blaze::IsClass_v = IsClass<T>::value
constexpr

Auxiliary variable template for the IsClass type trait.

The IsClass_v variable template provides a convenient shortcut to access the nested value of the IsClass class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsClass<T>::value;
constexpr bool value2 = blaze::IsClass_v<T>;
constexpr bool IsClass_v
Auxiliary variable template for the IsClass type trait.
Definition IsClass.h:97
Compile time type check.
Definition IsClass.h:79

◆ IsComplex_v

template<typename T>
bool blaze::IsComplex_v = IsComplex<T>::value
constexpr

Auxiliary variable template for the IsComplex type trait.

The IsComplex_v variable template provides a convenient shortcut to access the nested value of the IsComplex class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplex<T>::value;
constexpr bool value2 = blaze::IsComplex_v<T>;
constexpr bool IsComplex_v
Auxiliary variable template for the IsComplex type trait.
Definition IsComplex.h:139
Compile time check for complex types.
Definition IsComplex.h:77

◆ IsComplexDouble_v

template<typename T>
bool blaze::IsComplexDouble_v = IsComplexDouble<T>::value
constexpr

Auxiliary variable template for the IsComplexDouble type trait.

The IsComplexDouble_v variable template provides a convenient shortcut to access the nested value of the IsComplexDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplexDouble<T>::value;
constexpr bool value2 = blaze::IsComplexDouble_v<T>;
constexpr bool IsComplexDouble_v
Auxiliary variable template for the IsComplexDouble type trait.
Definition IsComplexDouble.h:139
Compile time check for single precision complex types.
Definition IsComplexDouble.h:77

◆ IsComplexFloat_v

template<typename T>
bool blaze::IsComplexFloat_v = IsComplexFloat<T>::value
constexpr

Auxiliary variable template for the IsComplexFloat type trait.

The IsComplexFloat_v variable template provides a convenient shortcut to access the nested value of the IsComplexFloat class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplexFloat<T>::value;
constexpr bool value2 = blaze::IsComplexFloat_v<T>;
constexpr bool IsComplexFloat_v
Auxiliary variable template for the IsComplexFloat type trait.
Definition IsComplexFloat.h:139
Compile time check for single precision complex types.
Definition IsComplexFloat.h:77

◆ IsConst_v

template<typename T>
bool blaze::IsConst_v = IsConst<T>::value
constexpr

Auxiliary variable template for the IsConst type trait.

The IsConst_v variable template provides a convenient shortcut to access the nested value of the IsConst class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsConst<T>::value;
constexpr bool value2 = blaze::IsConst_v<T>;
constexpr bool IsConst_v
Auxiliary variable template for the IsConst type trait.
Definition IsConst.h:95
Compile time check for constant data types.
Definition IsConst.h:77

◆ IsConstructible_v

template<typename T, typename... Args>
bool blaze::IsConstructible_v = IsConstructible<T>::value
constexpr

Auxiliary variable template for the IsConstructible type trait.

The IsConstructible_v variable template provides a convenient shortcut to access the nested value of the IsConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical:

constexpr bool value2 = blaze::IsConstructible_v<T1,T2,T3>;
constexpr bool IsConstructible_v
Auxiliary variable template for the IsConstructible type trait.
Definition IsConstructible.h:91
Compile time type check.
Definition IsConstructible.h:73

◆ IsConvertible_v

template<typename From, typename To>
bool blaze::IsConvertible_v = IsConvertible<From,To>::value
constexpr

Auxiliary variable template for the IsConvertible type trait.

The IsConvertible_v variable template provides a convenient shortcut to access the nested value of the IsConvertible class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsConvertible<T1,T2>::value;
constexpr bool value2 = blaze::IsConvertible_v<T1,T2>;
constexpr bool IsConvertible_v
Auxiliary variable template for the IsConvertible type trait.
Definition IsConvertible.h:107
Compile time pointer relationship constraint.
Definition IsConvertible.h:89

◆ IsCopyAssignable_v

template<typename T>
bool blaze::IsCopyAssignable_v = IsCopyAssignable<T>::value
constexpr

Auxiliary variable template for the IsCopyAssignable type trait.

The IsCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCopyAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCopyAssignable<T>::value;
constexpr bool value2 = blaze::IsCopyAssignable_v<T>;
constexpr bool IsCopyAssignable_v
Auxiliary variable template for the IsCopyAssignable type trait.
Definition IsAssignable.h:188
Compile time type check.
Definition IsAssignable.h:170

◆ IsCopyConstructible_v

template<typename T>
bool blaze::IsCopyConstructible_v = IsCopyConstructible<T>::value
constexpr

Auxiliary variable template for the IsCopyConstructible type trait.

The IsCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsCopyConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCopyConstructible<T>::value;
constexpr bool value2 = blaze::IsCopyConstructible_v<T>;
constexpr bool IsCopyConstructible_v
Auxiliary variable template for the IsCopyConstructible type trait.
Definition IsConstructible.h:283
Compile time type check.
Definition IsConstructible.h:265

◆ IsCUDAAssignable_v

template<typename T>
bool blaze::IsCUDAAssignable_v = IsCUDAAssignable<T>::value
constexpr

Auxiliary variable template for the IsCUDAAssignable type trait.

The IsCUDAAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCUDAAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCUDAAssignable<T>::value;
constexpr bool value2 = blaze::IsCUDAAssignable_v<T>;
constexpr bool IsCUDAAssignable_v
Auxiliary variable template for the IsCUDAAssignable type trait.
Definition IsCUDAAssignable.h:141
Compile time check for data types.
Definition IsCUDAAssignable.h:123

◆ IsDefaultConstructible_v

template<typename T>
bool blaze::IsDefaultConstructible_v = IsDefaultConstructible<T>::value
constexpr

Auxiliary variable template for the IsDefaultConstructible type trait.

The IsDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsDefaultConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsDefaultConstructible_v<T>;
constexpr bool IsDefaultConstructible_v
Auxiliary variable template for the IsDefaultConstructible type trait.
Definition IsConstructible.h:187
Compile time type check.
Definition IsConstructible.h:169

◆ IsDestructible_v

template<typename T>
bool blaze::IsDestructible_v = IsDestructible<T>::value
constexpr

Auxiliary variable template for the IsDestructible type trait.

The IsDestructible_v variable template provides a convenient shortcut to access the nested value of the IsDestructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDestructible<T>::value;
constexpr bool value2 = blaze::IsDestructible_v<T>;
constexpr bool IsDestructible_v
Auxiliary variable template for the IsDestructible type trait.
Definition IsDestructible.h:92
Compile time type check.
Definition IsDestructible.h:74

◆ IsDetected_v

template<template< typename... > class OP, typename... Ts>
bool blaze::IsDetected_v = IsDetected<OP,Ts...>::value
constexpr

Auxiliary variable template for the IsDetected type trait.

The IsDetected_v variable template provides a convenient shortcut to access the nested value of the IsDetected class template. For instance, given the template OP and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsDetected<OP,T1,T2>::value;
constexpr bool value2 = blaze::IsDetected_v<OP,T1,T2>;
typename DetectedOr< NoneSuch, OP, Ts... >::Value_t IsDetected
Compile time detection of type properties.
Definition IsDetected.h:151

◆ IsDouble_v

template<typename T>
bool blaze::IsDouble_v = IsDouble<T>::value
constexpr

Auxiliary variable template for the IsDouble type trait.

The IsDouble_v variable template provides a convenient shortcut to access the nested value of the IsDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDouble<T>::value;
constexpr bool value2 = blaze::IsDouble_v<T>;
constexpr bool IsDouble_v
Auxiliary variable template for the IsDouble type trait.
Definition IsDouble.h:138
Compile time check for double precision floating point types.
Definition IsDouble.h:76

◆ IsEmpty_v

template<typename T>
bool blaze::IsEmpty_v = IsEmpty<T>::value
constexpr

Auxiliary variable template for the IsEmpty type trait.

The IsEmpty_v variable template provides a convenient shortcut to access the nested value of the IsEmpty class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEmpty<T>::value;
constexpr bool value2 = blaze::IsEmpty_v<T>;
constexpr bool IsEmpty_v
Auxiliary variable template for the IsEmpty type trait.
Definition IsEmpty.h:98
Compile time type check.
Definition IsEmpty.h:80

◆ IsEnum_v

template<typename T>
bool blaze::IsEnum_v = IsEnum<T>::value
constexpr

Auxiliary variable template for the IsEnum type trait.

The IsEnum_v variable template provides a convenient shortcut to access the nested value of the IsEnum class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEnum<T>::value;
constexpr bool value2 = blaze::IsEnum_v<T>;
constexpr bool IsEnum_v
Auxiliary variable template for the IsEnum type trait.
Definition IsEnum.h:100
Compile time check for complete enumeration types.
Definition IsEnum.h:82

◆ IsFloat_v

template<typename T>
bool blaze::IsFloat_v = IsFloat<T>::value
constexpr

Auxiliary variable template for the IsFloat type trait.

The IsFloat_v variable template provides a convenient shortcut to access the nested value of the IsFloat class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsFloat<T>::value;
constexpr bool value2 = blaze::IsFloat_v<T>;
constexpr bool IsFloat_v
Auxiliary variable template for the IsFloat type trait.
Definition IsFloat.h:138
Compile time check for single precision floating point types.
Definition IsFloat.h:76

◆ IsFloatingPoint_v

template<typename T>
bool blaze::IsFloatingPoint_v = IsFloatingPoint<T>::value
constexpr

Auxiliary variable template for the IsFloatingPoint type trait.

The IsFloatingPoint_v variable template provides a convenient shortcut to access the nested value of the IsFloatingPoint class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsFloatingPoint<T>::value;
constexpr bool value2 = blaze::IsFloatingPoint_v<T>;
constexpr bool IsFloatingPoint_v
Auxiliary variable template for the IsFloatingPoint type trait.
Definition IsFloatingPoint.h:95
Compile time check for floating point data types.
Definition IsFloatingPoint.h:77

◆ IsInteger_v

template<typename T>
bool blaze::IsInteger_v = IsInteger<T>::value
constexpr

Auxiliary variable template for the IsInteger type trait.

The IsInteger_v variable template provides a convenient shortcut to access the nested value of the IsInteger class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsInteger<T>::value;
constexpr bool value2 = blaze::IsInteger_v<T>;
constexpr bool IsInteger_v
Auxiliary variable template for the IsInteger type trait.
Definition IsInteger.h:187
Compile time check for integer types.
Definition IsInteger.h:81

◆ IsIntegral_v

template<typename T>
bool blaze::IsIntegral_v = IsIntegral<T>::value
constexpr

Auxiliary variable template for the IsIntegral type trait.

The IsIntegral_v variable template provides a convenient shortcut to access the nested value of the IsIntegral class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsIntegral<T>::value;
constexpr bool value2 = blaze::IsIntegral_v<T>;
constexpr bool IsIntegral_v
Auxiliary variable template for the IsIntegral type trait.
Definition IsIntegral.h:95
Compile time check for integral data types.
Definition IsIntegral.h:77

◆ IsLong_v

template<typename T>
bool blaze::IsLong_v = IsLong<T>::value
constexpr

Auxiliary variable template for the IsLong type trait.

The IsLong_v variable template provides a convenient shortcut to access the nested value of the IsLong class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLong<T>::value;
constexpr bool value2 = blaze::IsLong_v<T>;
constexpr bool IsLong_v
Auxiliary variable template for the IsLong type trait.
Definition IsLong.h:183
Compile time check for long integer types.
Definition IsLong.h:77

◆ IsLongDouble_v

template<typename T>
bool blaze::IsLongDouble_v = IsLongDouble<T>::value
constexpr

Auxiliary variable template for the IsLongDouble type trait.

The IsLongDouble_v variable template provides a convenient shortcut to access the nested value of the IsLongDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLongDouble<T>::value;
constexpr bool value2 = blaze::IsLongDouble_v<T>;
constexpr bool IsLongDouble_v
Auxiliary variable template for the IsLongDouble type trait.
Definition IsLongDouble.h:138
Compile time check for extended precision floating point types.
Definition IsLongDouble.h:76

◆ IsLValueReference_v

template<typename T>
bool blaze::IsLValueReference_v = IsLValueReference<T>::value
constexpr

Auxiliary variable template for the IsLValueReference type trait.

The IsLValueReference_v variable template provides a convenient shortcut to access the nested value of the IsLValueReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLValueReference<T>::value;
constexpr bool value2 = blaze::IsLValueReference_v<T>;
constexpr bool IsLValueReference_v
Auxiliary variable template for the IsLValueReference type trait.
Definition IsLValueReference.h:96
Compile time type check.
Definition IsLValueReference.h:78

◆ IsMoveAssignable_v

template<typename T>
bool blaze::IsMoveAssignable_v = IsMoveAssignable<T>::value
constexpr

Auxiliary variable template for the IsMoveAssignable type trait.

The IsMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsMoveAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMoveAssignable<T>::value;
constexpr bool value2 = blaze::IsMoveAssignable_v<T>;
constexpr bool IsMoveAssignable_v
Auxiliary variable template for the IsMoveAssignable type trait.
Definition IsAssignable.h:285
Compile time type check.
Definition IsAssignable.h:267

◆ IsMoveConstructible_v

template<typename T>
bool blaze::IsMoveConstructible_v = IsMoveConstructible<T>::value
constexpr

Auxiliary variable template for the IsMoveConstructible type trait.

The IsMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsMoveConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMoveConstructible<T>::value;
constexpr bool value2 = blaze::IsMoveConstructible_v<T>;
constexpr bool IsMoveConstructible_v
Auxiliary variable template for the IsMoveConstructible type trait.
Definition IsConstructible.h:379
Compile time type check.
Definition IsConstructible.h:361

◆ IsNothrowAssignable_v

template<typename T, typename U>
bool blaze::IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value
constexpr

Auxiliary variable template for the IsNothrowAssignable type trait.

The IsNothrowAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowAssignable class template. For instance, given the types T and U the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowAssignable_v<T,U>;
constexpr bool IsNothrowAssignable_v
Auxiliary variable template for the IsNothrowAssignable type trait.
Definition IsAssignable.h:140
Compile time type check.
Definition IsAssignable.h:122

◆ IsNothrowConstructible_v

template<typename T, typename... Args>
bool blaze::IsNothrowConstructible_v = IsNothrowConstructible<T>::value
constexpr

Auxiliary variable template for the IsNothrowConstructible type trait.

The IsNothrowConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical:

constexpr bool IsNothrowConstructible_v
Auxiliary variable template for the IsNothrowConstructible type trait.
Definition IsConstructible.h:139
Compile time type check.
Definition IsConstructible.h:121

◆ IsNothrowCopyAssignable_v

template<typename T>
bool blaze::IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value
constexpr

Auxiliary variable template for the IsNothrowCopyAssignable type trait.

The IsNothrowCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowCopyAssignable_v<T>;
constexpr bool IsNothrowCopyAssignable_v
Auxiliary variable template for the IsNothrowCopyAssignable type trait.
Definition IsAssignable.h:237
Compile time type check.
Definition IsAssignable.h:219

◆ IsNothrowCopyConstructible_v

template<typename T>
bool blaze::IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value
constexpr

Auxiliary variable template for the IsNothrowCopyConstructible type trait.

The IsNothrowCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool IsNothrowCopyConstructible_v
Auxiliary variable template for the IsNothrowCopyConstructible type trait.
Definition IsConstructible.h:331
Compile time type check.
Definition IsConstructible.h:313

◆ IsNothrowDefaultConstructible_v

template<typename T>
bool blaze::IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value
constexpr

Auxiliary variable template for the IsNothrowDefaultConstructible type trait.

The IsNothrowDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDefaultConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool IsNothrowDefaultConstructible_v
Auxiliary variable template for the IsNothrowDefaultConstructible type trait.
Definition IsConstructible.h:235
Compile time type check.
Definition IsConstructible.h:217

◆ IsNothrowDestructible_v

template<typename T>
bool blaze::IsNothrowDestructible_v = IsNothrowDestructible<T>::value
constexpr

Auxiliary variable template for the IsNothrowDestructible type trait.

The IsNothrowDestructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDestructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowDestructible_v<T>;
constexpr bool IsNothrowDestructible_v
Auxiliary variable template for the IsNothrowDestructible type trait.
Definition IsDestructible.h:141
Compile time type check.
Definition IsDestructible.h:123

◆ IsNothrowMoveAssignable_v

template<typename T>
bool blaze::IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value
constexpr

Auxiliary variable template for the IsNothrowMoveAssignable type trait.

The IsNothrowMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowMoveAssignable_v<T>;
constexpr bool IsNothrowMoveAssignable_v
Auxiliary variable template for the IsNothrowMoveAssignable type trait.
Definition IsAssignable.h:334
Compile time type check.
Definition IsAssignable.h:316

◆ IsNothrowMoveConstructible_v

template<typename T>
bool blaze::IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value
constexpr

Auxiliary variable template for the IsNothrowMoveConstructible type trait.

The IsNothrowMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool IsNothrowMoveConstructible_v
Auxiliary variable template for the IsNothrowMoveConstructible type trait.
Definition IsConstructible.h:427
Compile time type check.
Definition IsConstructible.h:409

◆ IsNumeric_v

template<typename T>
bool blaze::IsNumeric_v = IsNumeric<T>::value
constexpr

Auxiliary variable template for the IsNumeric type trait.

The IsNumeric_v variable template provides a convenient shortcut to access the nested value of the IsNumeric class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNumeric<T>::value;
constexpr bool value2 = blaze::IsNumeric_v<T>;
constexpr bool IsNumeric_v
Auxiliary variable template for the IsNumeric type trait.
Definition IsNumeric.h:132
Compile time check for numeric types.
Definition IsNumeric.h:81

◆ IsObject_v

template<typename T>
bool blaze::IsObject_v = IsObject<T>::value
constexpr

Auxiliary variable template for the IsObject type trait.

The IsObject_v variable template provides a convenient shortcut to access the nested value of the IsObject class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsObject<T>::value;
constexpr bool value2 = blaze::IsObject_v<T>;
constexpr bool IsObject_v
Auxiliary variable template for the IsObject type trait.
Definition IsObject.h:96
Compile time type check.
Definition IsObject.h:78

◆ IsPod_v

template<typename T>
bool blaze::IsPod_v = IsPod<T>::value
constexpr

Auxiliary variable template for the IsPod type trait.

The IsPod_v variable template provides a convenient shortcut to access the nested value of the IsPod class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPod<T>::value;
constexpr bool value2 = blaze::IsPod_v<T>;
constexpr bool IsPod_v
Auxiliary variable template for the IsPod type trait.
Definition IsPod.h:107
Compile time check for pod data types.
Definition IsPod.h:89

◆ IsPointer_v

template<typename T>
bool blaze::IsPointer_v = IsPointer<T>::value
constexpr

Auxiliary variable template for the IsPointer type trait.

The IsPointer_v variable template provides a convenient shortcut to access the nested value of the IsPointer class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPointer<T>::value;
constexpr bool value2 = blaze::IsPointer_v<T>;
constexpr bool IsPointer_v
Auxiliary variable template for the IsPointer type trait.
Definition IsPointer.h:95
Compile time type check.
Definition IsPointer.h:77

◆ IsReference_v

template<typename T>
bool blaze::IsReference_v = IsReference<T>::value
constexpr

Auxiliary variable template for the IsReference type trait.

The IsReference_v variable template provides a convenient shortcut to access the nested value of the IsReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsReference<T>::value;
constexpr bool value2 = blaze::IsReference_v<T>;
constexpr bool IsReference_v
Auxiliary variable template for the IsReference type trait.
Definition IsReference.h:95
Compile time type check.
Definition IsReference.h:77

◆ IsRValueReference_v

template<typename T>
bool blaze::IsRValueReference_v = IsRValueReference<T>::value
constexpr

Auxiliary variable template for the IsRValueReference type trait.

The IsRValueReference_v variable template provides a convenient shortcut to access the nested value of the IsRValueReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRValueReference<T>::value;
constexpr bool value2 = blaze::IsRValueReference_v<T>;
constexpr bool IsRValueReference_v
Auxiliary variable template for the IsRValueReference type trait.
Definition IsRValueReference.h:97
Compile time type check.
Definition IsRValueReference.h:79

◆ IsSame_v

template<typename A, typename B>
bool blaze::IsSame_v = IsSame<A,B>::value
constexpr

Auxiliary variable template for the IsSame type trait.

The IsSame_v variable template provides a convenient shortcut to access the nested value of the IsSame class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsSame<T1,T2>::value;
constexpr bool value2 = blaze::IsSame_v<T1,T2>;
Type relationship analysis.
Definition IsSame.h:141

◆ IsShort_v

template<typename T>
bool blaze::IsShort_v = IsShort<T>::value
constexpr

Auxiliary variable template for the IsShort type trait.

The IsShort_v variable template provides a convenient shortcut to access the nested value of the IsShort class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsShort<T>::value;
constexpr bool value2 = blaze::IsShort_v<T>;
constexpr bool IsShort_v
Auxiliary variable template for the IsShort type trait.
Definition IsShort.h:183
Compile time check for short integer types.
Definition IsShort.h:77

◆ IsSigned_v

template<typename T>
bool blaze::IsSigned_v = IsSigned<T>::value
constexpr

Auxiliary variable template for the IsSigned type trait.

The IsSigned_v variable template provides a convenient shortcut to access the nested value of the IsSigned class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSigned<T>::value;
constexpr bool value2 = blaze::IsSigned_v<T>;
constexpr bool IsSigned_v
Auxiliary variable template for the IsSigned type trait.
Definition IsSigned.h:97
Compile time check for signed data types.
Definition IsSigned.h:79

◆ IsStrictlySame_v

template<typename A, typename B>
bool blaze::IsStrictlySame_v = IsStrictlySame<A,B>::value
constexpr

Auxiliary variable template for the IsStrictlySame type trait.

The IsStrictlySame_v variable template provides a convenient shortcut to access the nested value of the IsStrictlySame class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsStrictlySame<T1,T2>::value;
constexpr bool value2 = blaze::IsStrictlySame_v<T1,T2>;
constexpr bool IsStrictlySame_v
Auxiliary variable template for the IsStrictlySame type trait.
Definition IsSame.h:106
Compile time type relationship analysis.
Definition IsSame.h:77

◆ IsUnion_v

template<typename T>
bool blaze::IsUnion_v = IsUnion<T>::value
constexpr

Auxiliary variable template for the IsUnion type trait.

The IsUnion_v variable template provides a convenient shortcut to access the nested value of the IsUnion class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUnion<T>::value;
constexpr bool value2 = blaze::IsUnion_v<T>;
constexpr bool IsUnion_v
Auxiliary variable template for the IsUnion type trait.
Definition IsUnion.h:98
Compile time check for union data types.
Definition IsUnion.h:80

◆ IsUnsigned_v

template<typename T>
bool blaze::IsUnsigned_v = IsUnsigned<T>::value
constexpr

Auxiliary variable template for the IsUnsigned type trait.

The IsUnsigned_v variable template provides a convenient shortcut to access the nested value of the IsUnsigned class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUnsigned<T>::value;
constexpr bool value2 = blaze::IsUnsigned_v<T>;
constexpr bool IsUnsigned_v
Auxiliary variable template for the IsUnsigned type trait.
Definition IsUnsigned.h:97
Compile time check for unsigned data types.
Definition IsUnsigned.h:79

◆ IsValid_v

template<typename T>
bool blaze::IsValid_v = IsValid<T>::value
constexpr

Auxiliary variable template for the IsValid type trait.

The IsValid_v variable template provides a convenient shortcut to access the nested value of the IsValid class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsValid<T>::value;
constexpr bool value2 = blaze::IsValid_v<T>;
constexpr bool IsValid_v
Auxiliary variable template for the IsValid type trait.
Definition IsValid.h:139
Compile time type check.
Definition IsValid.h:77

◆ IsVectorizable_v

template<typename T>
bool blaze::IsVectorizable_v = IsVectorizable<T>::value
constexpr

Auxiliary variable template for the IsVectorizable type trait.

The IsVectorizable_v variable template provides a convenient shortcut to access the nested value of the IsVectorizable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVectorizable<T>::value;
constexpr bool value2 = blaze::IsVectorizable_v<T>;
constexpr bool IsVectorizable_v
Auxiliary variable template for the IsVectorizable type trait.
Definition IsVectorizable.h:157
Compile time check for vectorizable types.
Definition IsVectorizable.h:139

◆ IsVoid_v

template<typename T>
bool blaze::IsVoid_v = IsVoid<T>::value
constexpr

Auxiliary variable template for the IsVoid type trait.

The IsVoid_v variable template provides a convenient shortcut to access the nested value of the IsVoid class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVoid<T>::value;
constexpr bool value2 = blaze::IsVoid_v<T>;
constexpr bool IsVoid_v
Auxiliary variable template for the IsVoid type trait.
Definition IsVoid.h:95
Compile time check for the void data type.
Definition IsVoid.h:77

◆ IsVolatile_v

template<typename T>
bool blaze::IsVolatile_v = IsVolatile<T>::value
constexpr

Auxiliary variable template for the IsVolatile type trait.

The IsVolatile_v variable template provides a convenient shortcut to access the nested value of the IsVolatile class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVolatile<T>::value;
constexpr bool value2 = blaze::IsVolatile_v<T>;
constexpr bool IsVolatile_v
Auxiliary variable template for the IsVolatile type trait.
Definition IsVolatile.h:95
Compile time check for volatile data types.
Definition IsVolatile.h:77

◆ Length_v

template<typename TL>
size_t blaze::Length_v = Length<TL>::value
constexpr

Auxiliary variable template for the Length type trait.

The Length_v variable template provides a convenient shortcut to access the nested value of the Length class template. For instance, given the type list TL the following two statements are identical:

constexpr size_t value1 = Length<TL>::value;
constexpr size_t value2 = Length_v<TL>;
constexpr size_t Length_v
Auxiliary variable template for the Length type trait.
Definition Length.h:102
Calculating the length of a type list.
Definition Length.h:71

◆ Rank_v

template<typename T>
size_t blaze::Rank_v = Rank<T>::value
constexpr

Auxiliary variable template for the Rank type trait.

The Rank_v variable template provides a convenient shortcut to access the nested value of the Rank class template. For instance, given the type T the following two statements are identical:

constexpr size_t value1 = blaze::Rank<T>::value;
constexpr size_t value2 = blaze::Rank_v<T>;
constexpr size_t Rank_v
Auxiliary variable template for the Rank type trait.
Definition Rank.h:114
Compile time check for array ranks.
Definition Rank.h:74