TiledArray  0.7.0
Classes | Namespaces | Macros | Typedefs
type_traits.h File Reference
#include <TiledArray/config.h>
#include <iterator>
#include <madness/world/type_traits.h>
#include <complex>
#include <utility>
Include dependency graph for type_traits.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  Eigen::Matrix< typename, int, int, int, int, int >
 
class  Eigen::Array< typename, int, int, int, int, int >
 
class  Eigen::Map< typename, int, typename >
 
class  TiledArray::Tile< T >
 An N-dimensional shallow copy wrapper for tile objects. More...
 
class  TiledArray::DistArray< Tile, Policy >
 Forward declarations. More...
 
class  TiledArray::detail::LazyArrayTile< Tile, Op >
 Lazy tile for on-the-fly evaluation of array tiles. More...
 
struct  TiledArray::detail::is_type< typename >
 
struct  TiledArray::detail::make_void< Ts >
 
struct  TiledArray::eval_trait< T >
 Determine the object type used in the evaluation of tensor expressions. More...
 
struct  TiledArray::detail::has_conversion_operator< From, To, Enabler >
 
struct  TiledArray::detail::has_conversion_operator< From, To, typename std::enable_if< is_type< decltype(std::declval< From >().operator To())>::value >::type >
 
struct  TiledArray::detail::is_explicitly_convertible< From, To >
 
struct  TiledArray::detail::is_implicitly_convertible< From, To >
 
struct  TiledArray::detail::is_convertible< From, To >
 
struct  TiledArray::detail::eval_trait_base< T, Enabler >
 
struct  TiledArray::detail::eval_trait_base< T, typename std::enable_if< has_member_type_eval_type< T >::value &&(detail::is_explicitly_convertible< T, typename T::eval_type >::value||detail::is_explicitly_convertible< T, madness::Future< typename T::eval_type >>::value||detail::is_implicitly_convertible< T, typename T::eval_type >::value||detail::is_implicitly_convertible< T, madness::Future< typename T::eval_type >>::value)>::type >
 
struct  TiledArray::eval_trait< T >
 Determine the object type used in the evaluation of tensor expressions. More...
 
struct  TiledArray::is_lazy_tile< T >
 Detect lazy evaluation tiles. More...
 
struct  TiledArray::is_lazy_tile< DistArray< Tile, Policy > >
 
struct  TiledArray::is_consumable_tile< T >
 Consumable tile type trait. More...
 
struct  TiledArray::is_consumable_tile< ZeroTensor >
 
struct  TiledArray::detail::is_complex< T >
 
struct  TiledArray::detail::is_complex< std::complex< T > >
 
struct  TiledArray::detail::is_numeric< T >
 
struct  TiledArray::detail::is_numeric< std::complex< T > >
 
struct  TiledArray::detail::is_numeric< bool >
 
struct  TiledArray::detail::is_scalar< T >
 
struct  TiledArray::detail::is_scalar< std::complex< T > >
 
struct  TiledArray::detail::is_array_tile< T >
 Detect tiles used by ArrayEvalImpl. More...
 
struct  TiledArray::detail::is_array_tile< TiledArray::detail::LazyArrayTile< T, Op > >
 
struct  TiledArray::detail::is_non_array_lazy_tile< T >
 Detect a lazy evaluation tile that are not a LazyArrayTile. More...
 
struct  TiledArray::detail::numeric_type< T, Enabler >
 Type trait for extracting the numeric type of tensors and arrays. More...
 
struct  TiledArray::detail::numeric_type< T, typename std::enable_if< is_numeric< T >::value >::type >
 
struct  TiledArray::detail::numeric_type< T, typename std::enable_if< has_member_type_value_type< T >::value &&(! is_lazy_tile< T >::value) &&(! is_numeric< T >::value)>::type >
 
struct  TiledArray::detail::numeric_type< T, typename std::enable_if< is_lazy_tile< T >::value &&! is_numeric< T >::value >::type >
 
struct  TiledArray::detail::numeric_type< Eigen::Matrix< T, Rows, Cols, Opts, MaxRows, MaxCols >, void >
 
struct  TiledArray::detail::numeric_type< Eigen::Array< T, Rows, Cols, Opts, MaxRows, MaxCols >, void >
 
struct  TiledArray::detail::numeric_type< Tile< T >, void >
 
struct  TiledArray::detail::numeric_type< Eigen::Map< PlainObjectType, MapOptions, StrideType >, void >
 
struct  TiledArray::detail::scalar_type< T, Enabler >
 Type trait for extracting the scalar type of tensors and arrays. More...
 
struct  TiledArray::detail::scalar_type< T, typename std::enable_if< is_scalar< T >::value >::type >
 
struct  TiledArray::detail::scalar_type< std::complex< T >, void >
 
struct  TiledArray::detail::scalar_type< T, typename std::enable_if<!is_numeric< T >::value >::type >
 
struct  TiledArray::detail::is_strictly_ordered_helper< T >
 
struct  TiledArray::detail::is_strictly_ordered< T >
 
struct  TiledArray::detail::is_integral_list_helper<... >
 
struct  TiledArray::detail::is_integral_list_helper< T, Ts... >
 
struct  TiledArray::detail::is_integral_list_helper<>
 
struct  TiledArray::detail::is_integral_list< Ts >
 
struct  TiledArray::detail::is_tuple_< T, class >
 
struct  TiledArray::detail::is_tuple_< T, class >::type >
 
struct  TiledArray::detail::is_tuple< T >
 
struct  TiledArray::detail::is_integral_pair_< T, class >
 
struct  TiledArray::detail::is_integral_pair_< std::pair< T1, T2 >, typename std::enable_if< std::is_integral< T1 >::value &&std::is_integral< T2 >::value >::type >
 
struct  TiledArray::detail::is_integral_pair< T >
 
struct  TiledArray::detail::is_integral_pair_list_helper<... >
 
struct  TiledArray::detail::is_integral_pair_list_helper< T, Ts... >
 
struct  TiledArray::detail::is_integral_pair_list_helper<>
 
struct  TiledArray::detail::is_integral_pair_list< Ts >
 
struct  TiledArray::detail::is_integral_tuple< T >
 
struct  TiledArray::detail::is_integral_tuple< std::tuple< Ts... > >
 
struct  TiledArray::detail::remove_cvr< T >
 Remove const, volatile, and reference qualifiers. More...
 
struct  TiledArray::detail::param< T, Enabler >
 
struct  TiledArray::detail::param< T, typename std::enable_if< is_numeric< T >::value >::type >
 
struct  TiledArray::detail::param< T, typename std::enable_if< std::is_reference< T >::value >::type >
 
struct  TiledArray::detail::param< T, typename std::enable_if< std::is_pointer< T >::value >::type >
 
struct  TiledArray::detail::non_iterator_tag
 
struct  TiledArray::detail::is_iterator< T, Enabler >
 
struct  TiledArray::detail::is_iterator< T, typename std::enable_if< has_member_type_iterator_category< T >::value >::type >
 
struct  TiledArray::detail::is_iterator< T *, void >
 
struct  TiledArray::detail::is_iterator< const T *, void >
 
struct  TiledArray::detail::is_iterator< T *const, void >
 
struct  TiledArray::detail::is_iterator< const T *const, void >
 
struct  TiledArray::detail::is_input_iterator< T >
 
struct  TiledArray::detail::is_output_iterator< T >
 
struct  TiledArray::detail::is_forward_iterator< T >
 
struct  TiledArray::detail::is_bidirectional_iterator< T >
 
struct  TiledArray::detail::is_random_iterator< T >
 
struct  TiledArray::detail::is_array< T >
 
struct  TiledArray::detail::is_array< DistArray< T, P > >
 
struct  TiledArray::detail::is_dense< T >
 is_dense<T> is a true type if T is a dense array More...
 
struct  TiledArray::detail::is_dense< DistArray< Tile, DensePolicy > >
 
struct  TiledArray::detail::is_same_or_derived< Base, Derived >
 
struct  TiledArray::detail::is_pair< T >
 
struct  TiledArray::detail::is_pair< std::pair< T1, T2 > >
 

Namespaces

 Eigen
 Forward declarations.
 
 TiledArray
 
 TiledArray::detail
 

Macros

#define GENERATE_HAS_MEMBER(Member)
 
#define GENERATE_HAS_MEMBER_TYPE(Type)
 
#define GENERATE_HAS_MEMBER_FUNCTION(Member)
 
#define GENERATE_HAS_MEMBER_FUNCTION_ANYRETURN(Member)
 
#define GENERATE_IS_FREE_FUNCTION_ANYRETURN(Function)
 

Typedefs

template<typename... Ts>
using TiledArray::detail::void_t = typename make_void< Ts... >::type
 
template<typename T >
using TiledArray::detail::numeric_t = typename TiledArray::detail::numeric_type< T >::type
 
template<typename T >
using TiledArray::detail::scalar_t = typename TiledArray::detail::scalar_type< T >::type
 
template<bool B, typename T >
using TiledArray::detail::const_if_t = typename std::conditional< B, const T, T >::type
 prepends const to T if B is true More...
 
template<typename U >
using TiledArray::detail::param_type = typename param< U >::type
 
template<typename Scalar1 , typename Scalar2 >
using TiledArray::detail::add_t = decltype(std::declval< Scalar1 >()+std::declval< Scalar2 >())
 
template<typename Scalar1 , typename Scalar2 >
using TiledArray::detail::subt_t = decltype(std::declval< Scalar1 >() - std::declval< Scalar2 >())
 
template<typename Scalar1 , typename Scalar2 >
using TiledArray::detail::mult_t = decltype(std::declval< Scalar1 >() *std::declval< Scalar2 >())
 
template<typename T >
using TiledArray::detail::trange_t = typename T::trange_type
 
template<typename T >
using TiledArray::detail::shape_t = typename T::shape_type
 
template<typename T >
using TiledArray::detail::pmap_t = typename T::pmap_interface
 
template<typename T >
using TiledArray::detail::policy_t = typename T::policy_type
 

Macro Definition Documentation

◆ GENERATE_HAS_MEMBER

#define GENERATE_HAS_MEMBER (   Member)
Value:
template <typename T, typename Enabler = void> \
class __has_member_##Member : public std::false_type {}; \
template <typename T> \
class __has_member_##Member< \
T, typename std::enable_if<std::is_class<T>::value || \
std::is_union<T>::value>::type> { \
using Yes = char[2]; \
using No = char[1]; \
\
struct Fallback { \
int Member; \
}; \
struct Derived : T, Fallback {}; \
\
template <class U> \
static No& test(decltype(U::Member) *); \
template <typename U> \
static Yes& test(U*); \
\
public: \
static constexpr bool value = \
sizeof(test<Derived>(nullptr)) == sizeof(Yes); \
}; \
\
template <class T> \
struct has_member_##Member \
: public std::integral_constant<bool, __has_member_##Member<T>::value> { \
};

this generates struct has_member_##Type<T> whose public constexpr member variable value is true if T::Member is a member variable or function.

Definition at line 56 of file type_traits.h.

◆ GENERATE_HAS_MEMBER_FUNCTION

#define GENERATE_HAS_MEMBER_FUNCTION (   Member)
Value:
template <typename T, typename Result, typename... Args> \
class __has_member_function_##Member { \
using Yes = char; \
using No = int; \
template <typename U, Result (U::*)(Args...)> \
struct Check; \
template <typename U, Result (U::*)(Args...) const> \
struct CheckConst; \
template <typename U> \
static Yes test_const(CheckConst<U, &U::Member>*); \
template <typename U> \
static No test_const(...); \
template <typename U> \
static Yes test_nonconst(Check<U, &U::Member>*); \
template <typename U> \
static No test_nonconst(...); \
\
public: \
static constexpr const bool value = \
sizeof(test_const<T>(0)) == sizeof(Yes) || \
(!std::is_const<T>::value ? sizeof(test_nonconst<T>(0)) == sizeof(Yes) \
: false); \
}; \
template <class T, typename Result, typename... Args> \
struct has_member_function_##Member \
: public std::integral_constant< \
bool, __has_member_function_##Member<T, Result, Args...>::value> { \
};

this generates struct has_member_function_Member<T,R,Args...> whose public constexpr member variable value is true if T::Member is a member function that takes Args and returns R .

Note
if T is a const type, only const member functions will be detected, hence has_member_function_Member_anyreturn<const T,R,Args...>::value && !has_member_function_Member_anyreturn<T,R,Args...>::value evaluates to true if there is only a const T::Member

Definition at line 127 of file type_traits.h.

◆ GENERATE_HAS_MEMBER_FUNCTION_ANYRETURN

#define GENERATE_HAS_MEMBER_FUNCTION_ANYRETURN (   Member)
Value:
template <typename T, typename... Args> \
class __has_member_function_##Member##_anyreturn { \
using Yes = char; \
using No = int; \
template <typename U, typename... Args_> \
static auto func(void*) \
-> decltype(std::add_pointer_t<decltype(std::declval<U>().Member( \
std::declval<Args_>()...))>{}, \
Yes{}); \
template <typename U, typename... Args_> \
static No func(...); \
\
public: \
static constexpr const bool value = \
sizeof(func<T, Args...>(0)) == sizeof(Yes); \
}; \
template <class T, typename... Args> \
struct has_member_function_##Member##_anyreturn \
: public std::integral_constant< \
bool, \
__has_member_function_##Member##_anyreturn<T, Args...>::value> {};

this generates struct has_member_function_Member_anyreturn<T,Args...> whose public constexpr member variable value is true if T::Member is a member function that takes Args and returns any type.

Note
if T is a const type, only const member functions will be detected, hence has_member_function_Member_anyreturn<const T,Args...>::value && !has_member_function_Member_anyreturn<T,Args...>::value evaluates to true if there is only a const T::Member

Definition at line 165 of file type_traits.h.

◆ GENERATE_HAS_MEMBER_TYPE

#define GENERATE_HAS_MEMBER_TYPE (   Type)
Value:
template <typename T, typename Enabler = void> \
class __has_member_type_##Type : public std::false_type {}; \
template <typename T> \
class __has_member_type_##Type< \
T, typename std::enable_if<std::is_class<T>::value || \
std::is_union<T>::value>::type> { \
using Yes = char[2]; \
using No = char[1]; \
\
struct Fallback { \
struct Type {}; \
}; \
struct Derived : T, Fallback {}; \
\
template <class U> \
static No& test(typename U::Type*); \
template <typename U> \
static Yes& test(U*); \
\
public: \
static constexpr bool value = \
sizeof(test<Derived>(nullptr)) == sizeof(Yes); \
}; \
\
template <class T> \
struct has_member_type_##Type \
: public std::integral_constant<bool, \
__has_member_type_##Type<T>::value> {};

this generates struct has_member_type_##Type<T> whose public constexpr member variable value is true if T::Member is a valid type.

Definition at line 89 of file type_traits.h.

◆ GENERATE_IS_FREE_FUNCTION_ANYRETURN

#define GENERATE_IS_FREE_FUNCTION_ANYRETURN (   Function)
Value:
template <typename... Args> \
class __is_free_function_##Function##_anyreturn { \
using Yes = char; \
using No = int; \
template <typename... Args_> \
static auto func(void*) -> decltype( \
std::add_pointer_t<decltype(Function(std::declval<Args_>()...))>{}, \
Yes{}); \
template <typename...> \
static No func(...); \
\
public: \
static constexpr const bool value = \
sizeof(func<Args...>(0)) == sizeof(Yes); \
}; \
template <typename... Args> \
struct is_free_function_##Function##_anyreturn \
: public std::integral_constant< \
bool, __is_free_function_##Function##_anyreturn<Args...>::value> { \
};

this generates struct is_free_function_Function_anyreturn<Args...> whose public constexpr member variable value is true if Function is a free function that takes Args and returns any value.

Note
to ensure that Function can be looked up, it may be necessary to add "using namespace::Function" BEFORE using this macro.

Definition at line 193 of file type_traits.h.