#include <src/vt/topos/index/traits/traits.h>

template<typename T>

vt::index::IndexTraits struct

Public types

template<typename U>

using IndexSizeType_t = typename U::IndexSizeType

using has_IndexSizeType = detection::is_detected<IndexSizeType_t, T>

template<typename U, typename... Vs>

using constructor_t = decltype(U(std::declval<Vs>()...))

using has_default_constructor = detection::is_detected<constructor_t, T>

template<typename U>

using copy_constructor_t = decltype(U(std::declval<U const &>()))

using has_copy_constructor = detection::is_detected<copy_constructor_t, T>

template<typename U>

using copy_assignment_t = decltype(std::declval<U>().operator=(std::declval<U const &>()))

using has_copy_assignment = detection::is_detected_convertible<T, copy_assignment_t, T>

template<typename U>

using operator_eq_t = decltype(U(std::declval<U>().operator=(std::declval<U const &>())))

using has_operator_eq = detection::is_detected<operator_eq_t, T>

template<typename U>

using equality_t = decltype(std::declval<U>().operator==(std::declval<U const &>()))

using has_equality = detection::is_detected<equality_t, T>

template<typename U>

using packedSize_t = decltype(std::declval<U const &>().packedSize())

using has_packedSize = detection::is_detected_convertible<size_t, packedSize_t, T>

template<typename U>

using indexIsByteCopyable_t = decltype(std::declval<U const &>().indexIsByteCopyable())

using has_indexIsByteCopyable = detection::is_detected<indexIsByteCopyable_t, T>

template<typename U>

using uniqueBits_t = decltype(std::declval<U const &>().uniqueBits())

using has_uniqueBits = detection::is_detected_convertible<UniqueIndexBitType, uniqueBits_t, T>

template<typename U>

using ApplyType = std::function<void(U)>

template<typename U>

using foreach_t = decltype(std::declval<U const &>().foreach(std::declval<U const &>(), std::declval<ApplyType<U>>()))

using has_foreach = detection::is_detected<foreach_t, T>

template<typename U>

using IsByteCopyable_t = typename U::IsByteCopyable

using has_IsByteCopyable = detection::is_detected<IsByteCopyable_t, T>

template<typename U>

using toString_t = decltype(std::declval<U const &>().toString())

using has_toString = detection::is_detected_convertible<std::string, toString_t, T>

template<typename U>

using numDims_t = decltype(std::declval<U const &>().ndims())

using has_numDims = detection::is_detected_convertible<int8_t, numDims_t, T>

template<typename U>

using build_index_t = typename U::BuildIndexType

using has_build_index = detection::is_detected<build_index_t, T>

Public static variables

static const auto is_index constexpr