Classes | Typedefs | Variables
tt Namespace Reference

Classes

struct  can_be_copy_constructed
 Check if T is copy constructible. More...
 
struct  ConformsTo
 Indicate a class conforms to the Protocol. More...
 
struct  get_fundamental_type
 Extracts the fundamental type for a container. More...
 
struct  has_equivalence
 Check if type T has operator== defined. More...
 
struct  has_inequivalence
 Check if type T has operator!= defined. 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_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_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_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
 
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 T >
using is_tensor_index_type_t = typename is_tensor_index_type< T >::type
 
template<typename ConformingType , typename Protocol >
using conforms_to = typename std::is_convertible< ConformingType *, ConformsTo< Protocol > * >
 Checks if the ConformingType conforms to the Protocol. More...
 
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 F >
using function_info = 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 >
using get_fundamental_type_t = typename get_fundamental_type< T >::type
 
template<typename T >
using has_equivalence_t = typename has_equivalence< T >::type
 
template<typename T >
using has_inequivalence_t = typename has_inequivalence< T >::type
 
template<template< typename... > class U, typename... Args>
using is_a_t = typename is_a< U, Args... >::type
 
template<template< typename > class U, typename T >
using is_a_lambda = detail::wrapped_is_a< detail::is_a_wrapper< U >, T >
 
template<typename T , typename... Args>
using is_callable_t = typename is_callable< T, Args... >::type
 
template<typename T >
using is_iterable_t = typename is_iterable< T >::type
 
template<typename T >
using is_maplike_t = typename is_maplike< T >::type
 
template<typename T >
using is_std_array_t = typename is_std_array< T >::type
 
template<size_t N, typename T >
using is_std_array_of_size_t = typename is_std_array_of_size< N, T >::type
 
template<typename S , typename T >
using is_streamable_t = typename is_streamable< S, T >::type
 
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
 

Variables

template<typename ConformingType , typename Protocol >
constexpr bool conforms_to_v
 
template<typename T >
constexpr bool can_be_copy_constructed_v = can_be_copy_constructed<T>::value
 
template<typename T >
constexpr bool has_equivalence_v = has_equivalence<T>::value
 
template<typename T >
constexpr bool has_inequivalence_v = has_inequivalence<T>::value
 
template<template< typename... > class U, typename... Args>
constexpr bool is_a_v = is_a<U, Args...>::value
 
template<typename T , typename... Args>
constexpr bool is_callable_v = is_callable<T, Args...>::value
 
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 is_integer_v = is_integer<T>::value
 
template<typename T >
constexpr bool is_iterable_v = is_iterable<T>::value
 
template<typename T >
constexpr bool is_maplike_v = is_maplike<T>::value
 
template<typename T >
constexpr bool is_std_array_v = is_std_array<T>::value
 
template<size_t N, typename T >
constexpr bool is_std_array_of_size_v = is_std_array_of_size<N, T>::value
 
template<typename S , typename T >
constexpr bool is_streamable_v = is_streamable<S, T>::value
 

Detailed Description

A collection of useful type traits

Typedef Documentation

◆ has_equivalence_t

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

◆ has_inequivalence_t

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

◆ 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_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_tensor_index_type_t

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

Variable Documentation

◆ conforms_to_v

template<typename ConformingType , typename Protocol >
constexpr bool tt::conforms_to_v
constexpr
Initial value:
=
std::is_convertible_v<ConformingType*, ConformsTo<Protocol>*>

◆ has_equivalence_v

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

◆ has_inequivalence_v

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

◆ is_a_v

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

◆ is_callable_v

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

◆ is_complex_of_fundamental_v

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

◆ is_integer_v

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

◆ is_iterable_v

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

◆ is_maplike_v

template<typename T >
constexpr bool tt::is_maplike_v = is_maplike<T>::value
constexpr
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
constexpr

◆ is_std_array_v

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

◆ is_streamable_v

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