Classes | Typedefs | Variables
tt Namespace Reference

A collection of useful type traits. More...

Classes

struct  can_be_copy_constructed
 Check if T is copy constructible. More...
 
struct  get_fundamental_type
 Extracts the fundamental type for a container. More...
 
struct  has_clone
 Check if type T has a clone() member function. More...
 
struct  has_equivalence
 Check if type T has operator== defined. More...
 
struct  has_get_clone
 Check if type T has a get_clone() member function. More...
 
struct  has_inequivalence
 Check if type T has operator!= defined. More...
 
struct  has_size
 Check if type T has a size() member function. More...
 
struct  is_a
 Check if type T is a template specialization of U More...
 
class  is_callable
 Check if a type T is callable, i.e. T(Args...) is evaluable. More...
 
struct  is_comparable
 Check if type T has <, <=, >, >=, ==, !=. More...
 
struct  is_complex_of_fundamental
 Determines if a type T is a std::complex of a fundamental type, is a std::true_type if so, and otherwise is a std::false_type More...
 
struct  is_hashable
 Check if std::hash and std::equal_to are defined for type T. More...
 
struct  is_integer
 Check if I is an integer type (non-bool, non-character), unlike std::is_integral. More...
 
struct  is_iterable
 Check if type T has a begin() and end() function. More...
 
struct  is_maplike
 Check if type T is like a std::map or std::unordored_map. More...
 
struct  is_std_array
 Check if type T is a std::array. More...
 
struct  is_std_array_of_size
 Check if type T is a std::array of a given size. More...
 
struct  is_streamable
 Check if type T has operator<<(S, T) defined. More...
 
struct  is_string_like
 Check if type T is a std::string, or a C-style string. More...
 
struct  is_tensor_index
 Check if a type T is a TensorIndex used in TensorExpressions. More...
 
struct  is_tensor_index< TensorIndex< I > >
 
struct  is_tensor_index_type
 Inherits from std::true_type if T is a TensorIndexType. More...
 
struct  remove_cvref_wrap
 Removes std::reference_wrapper, references, and cv qualifiers. More...
 
struct  remove_reference_wrapper
 Gets the underlying type if the type is a std::reference_wrapper, otherwise returns the type itself. More...
 

Typedefs

template<typename F >
using function_info = tt_detail::function_info_impl< F >
 Returns a struct that contains the return type, argument types, and the class type if the F is a non-static member function. More...
 
template<typename T , size_t = 0>
using identity_t = T
 Given a type T and possibly a size_t evaluates to T. Useful for turning a std::index_sequence into a pack expansion of types. More...
 
template<typename T >
using is_tensor_index_type_t = typename is_tensor_index_type< T >::type
 
template<typename Array >
using array_size = decltype(TypeTraits_detail::array_size_impl(std::declval< const Array & >()))
 Get the size of a std::array as a std::integral_constant. More...
 
template<typename T >
using remove_reference_wrapper_t = typename remove_reference_wrapper< T >::type
 
template<typename T >
using remove_cvref_wrap_t = typename remove_cvref_wrap< T >::type
 
template<typename T >
using get_fundamental_type_t = typename get_fundamental_type< T >::type
 

Variables

template<typename T >
constexpr bool is_complex_of_fundamental_v
 
template<typename T >
constexpr bool is_complex_or_fundamental_v
 Evaluates to true if type T is a std::complex of a fundamental type or if T is a fundamental type. More...
 
template<typename T >
constexpr bool can_be_copy_constructed_v = can_be_copy_constructed<T>::value
 
template<typename T >
constexpr bool is_integer_v = is_integer<T>::value
 
template<typename T >
using is_std_array_t = typename is_std_array< T >::type
 
template<typename T >
constexpr bool is_std_array_v = is_std_array<T>::value
 
template<size_t N, typename T >
using is_std_array_of_size_t = typename is_std_array_of_size< N, T >::type
 
template<size_t N, typename T >
constexpr bool is_std_array_of_size_v = is_std_array_of_size<N, T>::value
 
template<template< typename... > class U, typename... Args>
using is_a_t = typename is_a< U, Args... >::type
 
template<template< typename... > class U, typename... Args>
constexpr bool is_a_v = is_a<U, Args...>::value
 
template<typename T >
using is_iterable_t = typename is_iterable< T >::type
 
template<typename T >
constexpr bool is_iterable_v = is_iterable<T>::value
 
template<typename T >
using is_comparable_t = typename is_comparable< T >::type
 
template<typename T >
constexpr bool is_comparable_v = is_comparable<T>::value
 
template<typename T >
using has_equivalence_t = typename has_equivalence< T >::type
 
template<typename T >
constexpr bool has_equivalence_v = has_equivalence<T>::value
 
template<typename T >
using has_inequivalence_t = typename has_inequivalence< T >::type
 
template<typename T >
constexpr bool has_inequivalence_v = has_inequivalence<T>::value
 
template<typename T , typename... Args>
using is_callable_t = typename is_callable< T, Args... >::type
 
template<typename T , typename... Args>
constexpr bool is_callable_v = is_callable<T, Args...>::value
 
template<typename T >
using is_hashable_t = typename is_hashable< T >::type
 
template<typename T >
constexpr bool is_hashable_v = is_hashable<T>::value
 
template<typename T >
using is_maplike_t = typename is_maplike< T >::type
 
template<typename T >
constexpr bool is_maplike_v = is_maplike<T>::value
 
template<typename S , typename T >
using is_streamable_t = typename is_streamable< S, T >::type
 
template<typename S , typename T >
constexpr bool is_streamable_v = is_streamable<S, T>::value
 
template<typename T >
using is_string_like_t = typename is_string_like< T >::type
 
template<typename T >
constexpr bool is_string_like_v = is_string_like<T>::value
 
template<typename T >
using has_get_clone_t = typename has_get_clone< T >::type
 
template<typename T >
constexpr bool has_get_clone_v = has_get_clone<T>::value
 
template<typename T >
using has_clone_t = typename has_clone< T >::type
 
template<typename T >
constexpr bool has_clone_v = has_clone<T>::value
 
template<typename T >
using has_size_t = typename has_size< T >::type
 
template<typename T >
constexpr bool has_size_v = has_size<T>::value
 

Detailed Description

A collection of useful type traits.

Typedef Documentation

◆ has_clone_t

template<typename T >
using tt::has_clone_t = typedef typename has_clone<T>::type
See also
has_clone

◆ has_equivalence_t

template<typename T >
using tt::has_equivalence_t = typedef typename has_equivalence<T>::type
See also
has_equivalence

◆ has_get_clone_t

template<typename T >
using tt::has_get_clone_t = typedef typename has_get_clone<T>::type
See also
has_get_clone

◆ has_inequivalence_t

template<typename T >
using tt::has_inequivalence_t = typedef typename has_inequivalence<T>::type

◆ has_size_t

template<typename T >
using tt::has_size_t = typedef typename has_size<T>::type
See also
has_size

◆ is_a_t

template<template< typename... > class U, typename... Args>
using tt::is_a_t = typedef typename is_a<U, Args...>::type
See also
is_a

◆ is_callable_t

template<typename T , typename... Args>
using tt::is_callable_t = typedef typename is_callable<T, Args...>::type
See also
is_callable

◆ is_comparable_t

template<typename T >
using tt::is_comparable_t = typedef typename is_comparable<T>::type
See also
is_comparable

◆ is_hashable_t

template<typename T >
using tt::is_hashable_t = typedef typename is_hashable<T>::type
See also
is_hashable

◆ is_iterable_t

template<typename T >
using tt::is_iterable_t = typedef typename is_iterable<T>::type
See also
is_iterable

◆ is_maplike_t

template<typename T >
using tt::is_maplike_t = typedef typename is_maplike<T>::type
See also
is_maplike

◆ is_std_array_of_size_t

template<size_t N, typename T >
using tt::is_std_array_of_size_t = typedef typename is_std_array_of_size<N, T>::type

◆ is_std_array_t

template<typename T >
using tt::is_std_array_t = typedef typename is_std_array<T>::type
See also
is_std_array

◆ is_streamable_t

template<typename S , typename T >
using tt::is_streamable_t = typedef typename is_streamable<S, T>::type
See also
is_streamable

◆ is_string_like_t

template<typename T >
using tt::is_string_like_t = typedef typename is_string_like<T>::type
See also
is_string_like

◆ is_tensor_index_type_t

template<typename T >
using tt::is_tensor_index_type_t = typedef typename is_tensor_index_type<T>::type

Variable Documentation

◆ has_clone_v

template<typename T >
constexpr bool tt::has_clone_v = has_clone<T>::value
See also
has_clone

◆ has_equivalence_v

template<typename T >
constexpr bool tt::has_equivalence_v = has_equivalence<T>::value
See also
has_equivalence

◆ has_get_clone_v

template<typename T >
constexpr bool tt::has_get_clone_v = has_get_clone<T>::value
See also
has_get_clone

◆ has_inequivalence_v

template<typename T >
constexpr bool tt::has_inequivalence_v = has_inequivalence<T>::value

◆ has_size_v

template<typename T >
constexpr bool tt::has_size_v = has_size<T>::value
See also
has_size

◆ is_a_v

template<template< typename... > class U, typename... Args>
constexpr bool tt::is_a_v = is_a<U, Args...>::value
See also
is_a

◆ is_callable_v

template<typename T , typename... Args>
constexpr bool tt::is_callable_v = is_callable<T, Args...>::value
See also
is_callable

◆ is_comparable_v

template<typename T >
constexpr bool tt::is_comparable_v = is_comparable<T>::value
See also
is_comparable

◆ is_complex_of_fundamental_v

template<typename T >
constexpr bool tt::is_complex_of_fundamental_v
Initial value:
=
is_complex_of_fundamental<T>::value

◆ is_hashable_v

template<typename T >
constexpr bool tt::is_hashable_v = is_hashable<T>::value
See also
is_hashable

◆ is_integer_v

template<typename T >
constexpr bool tt::is_integer_v = is_integer<T>::value
See also
is_integer

◆ is_iterable_v

template<typename T >
constexpr bool tt::is_iterable_v = is_iterable<T>::value
See also
is_iterable

◆ is_maplike_v

template<typename T >
constexpr bool tt::is_maplike_v = is_maplike<T>::value
See also
is_maplike

◆ is_std_array_of_size_v

template<size_t N, typename T >
constexpr bool tt::is_std_array_of_size_v = is_std_array_of_size<N, T>::value

◆ is_std_array_v

template<typename T >
constexpr bool tt::is_std_array_v = is_std_array<T>::value
See also
is_std_array

◆ is_streamable_v

template<typename S , typename T >
constexpr bool tt::is_streamable_v = is_streamable<S, T>::value
See also
is_streamable

◆ is_string_like_v

template<typename T >
constexpr bool tt::is_string_like_v = is_string_like<T>::value
See also
is_string_like