type_traits.hpp

Extensions on the standard library type traits to handle Empirical classes (such as Ptr).

This file is part of Empirical, https://github.com/devosoft/Empirical Copyright (C) 2016-2024 Michigan State University MIT Software license; see doc/LICENSE.md

Defines

INCLUDE_EMP_META_TYPE_TRAITS_HPP_GUARD

Typedefs

template<typename ...Ts>
using has_any_void = has_trait_any<std::is_void, Ts...>
template<typename ...Ts>
using has_only_void = has_trait_all<std::is_void, Ts...>
template<typename ...Ts>
using has_no_void = has_trait_none<std::is_void, Ts...>
template<typename ...Ts>
using has_any_null_pointer = has_trait_any<std::is_null_pointer, Ts...>
template<typename ...Ts>
using has_only_null_pointer = has_trait_all<std::is_null_pointer, Ts...>
template<typename ...Ts>
using has_no_null_pointer = has_trait_none<std::is_null_pointer, Ts...>
template<typename ...Ts>
using has_any_integral = has_trait_any<std::is_integral, Ts...>
template<typename ...Ts>
using has_only_integral = has_trait_all<std::is_integral, Ts...>
template<typename ...Ts>
using has_no_integral = has_trait_none<std::is_integral, Ts...>
template<typename ...Ts>
using has_any_floating_point = has_trait_any<std::is_floating_point, Ts...>
template<typename ...Ts>
using has_only_floating_point = has_trait_all<std::is_floating_point, Ts...>
template<typename ...Ts>
using has_no_floating_point = has_trait_none<std::is_floating_point, Ts...>
template<typename ...Ts>
using has_any_array = has_trait_any<std::is_array, Ts...>
template<typename ...Ts>
using has_only_array = has_trait_all<std::is_array, Ts...>
template<typename ...Ts>
using has_no_array = has_trait_none<std::is_array, Ts...>
template<typename ...Ts>
using has_any_enum = has_trait_any<std::is_enum, Ts...>
template<typename ...Ts>
using has_only_enum = has_trait_all<std::is_enum, Ts...>
template<typename ...Ts>
using has_no_enum = has_trait_none<std::is_enum, Ts...>
template<typename ...Ts>
using has_any_union = has_trait_any<std::is_union, Ts...>
template<typename ...Ts>
using has_only_union = has_trait_all<std::is_union, Ts...>
template<typename ...Ts>
using has_no_union = has_trait_none<std::is_union, Ts...>
template<typename ...Ts>
using has_any_class = has_trait_any<std::is_class, Ts...>
template<typename ...Ts>
using has_only_class = has_trait_all<std::is_class, Ts...>
template<typename ...Ts>
using has_no_class = has_trait_none<std::is_class, Ts...>
template<typename ...Ts>
using has_any_function = has_trait_any<std::is_function, Ts...>
template<typename ...Ts>
using has_only_function = has_trait_all<std::is_function, Ts...>
template<typename ...Ts>
using has_no_function = has_trait_none<std::is_function, Ts...>
template<typename ...Ts>
using has_any_pointer = has_trait_any<std::is_pointer, Ts...>
template<typename ...Ts>
using has_only_pointer = has_trait_all<std::is_pointer, Ts...>
template<typename ...Ts>
using has_no_pointer = has_trait_none<std::is_pointer, Ts...>
template<typename ...Ts>
using has_any_lvalue_reference = has_trait_any<std::is_lvalue_reference, Ts...>
template<typename ...Ts>
using has_only_lvalue_reference = has_trait_all<std::is_lvalue_reference, Ts...>
template<typename ...Ts>
using has_no_lvalue_reference = has_trait_none<std::is_lvalue_reference, Ts...>
template<typename ...Ts>
using has_any_rvalue_reference = has_trait_any<std::is_rvalue_reference, Ts...>
template<typename ...Ts>
using has_only_rvalue_reference = has_trait_all<std::is_rvalue_reference, Ts...>
template<typename ...Ts>
using has_no_rvalue_reference = has_trait_none<std::is_rvalue_reference, Ts...>
template<typename ...Ts>
using has_any_member_object_pointer = has_trait_any<std::is_member_object_pointer, Ts...>
template<typename ...Ts>
using has_only_member_object_pointer = has_trait_all<std::is_member_object_pointer, Ts...>
template<typename ...Ts>
using has_no_member_object_pointer = has_trait_none<std::is_member_object_pointer, Ts...>
template<typename ...Ts>
using has_any_member_function_pointer = has_trait_any<std::is_member_function_pointer, Ts...>
template<typename ...Ts>
using has_only_member_function_pointer = has_trait_all<std::is_member_function_pointer, Ts...>
template<typename ...Ts>
using has_no_member_function_pointer = has_trait_none<std::is_member_function_pointer, Ts...>
template<typename ...Ts>
using has_any_fundamental = has_trait_any<std::is_fundamental, Ts...>
template<typename ...Ts>
using has_only_fundamental = has_trait_all<std::is_fundamental, Ts...>
template<typename ...Ts>
using has_no_fundamental = has_trait_none<std::is_fundamental, Ts...>
template<typename ...Ts>
using has_any_arithmetic = has_trait_any<std::is_arithmetic, Ts...>
template<typename ...Ts>
using has_only_arithmetic = has_trait_all<std::is_arithmetic, Ts...>
template<typename ...Ts>
using has_no_arithmetic = has_trait_none<std::is_arithmetic, Ts...>
template<typename ...Ts>
using has_any_scalar = has_trait_any<std::is_scalar, Ts...>
template<typename ...Ts>
using has_only_scalar = has_trait_all<std::is_scalar, Ts...>
template<typename ...Ts>
using has_no_scalar = has_trait_none<std::is_scalar, Ts...>
template<typename ...Ts>
using has_any_object = has_trait_any<std::is_object, Ts...>
template<typename ...Ts>
using has_only_object = has_trait_all<std::is_object, Ts...>
template<typename ...Ts>
using has_no_object = has_trait_none<std::is_object, Ts...>
template<typename ...Ts>
using has_any_compound = has_trait_any<std::is_compound, Ts...>
template<typename ...Ts>
using has_only_compound = has_trait_all<std::is_compound, Ts...>
template<typename ...Ts>
using has_no_compound = has_trait_none<std::is_compound, Ts...>
template<typename ...Ts>
using has_any_reference = has_trait_any<std::is_reference, Ts...>
template<typename ...Ts>
using has_only_reference = has_trait_all<std::is_reference, Ts...>
template<typename ...Ts>
using has_no_reference = has_trait_none<std::is_reference, Ts...>
template<typename ...Ts>
using has_any_member_pointer = has_trait_any<std::is_member_pointer, Ts...>
template<typename ...Ts>
using has_only_member_pointer = has_trait_all<std::is_member_pointer, Ts...>
template<typename ...Ts>
using has_no_member_pointer = has_trait_none<std::is_member_pointer, Ts...>
template<typename ...Ts>
using has_any_const = has_trait_any<std::is_const, Ts...>
template<typename ...Ts>
using has_only_const = has_trait_all<std::is_const, Ts...>
template<typename ...Ts>
using has_no_const = has_trait_none<std::is_const, Ts...>
template<typename ...Ts>
using has_any_volatile = has_trait_any<std::is_volatile, Ts...>
template<typename ...Ts>
using has_only_volatile = has_trait_all<std::is_volatile, Ts...>
template<typename ...Ts>
using has_no_volatile = has_trait_none<std::is_volatile, Ts...>
template<typename ...Ts>
using has_any_trivial = has_trait_any<std::is_trivial, Ts...>
template<typename ...Ts>
using has_only_trivial = has_trait_all<std::is_trivial, Ts...>
template<typename ...Ts>
using has_no_trivial = has_trait_none<std::is_trivial, Ts...>
template<typename ...Ts>
using has_any_trivially_copyable = has_trait_any<std::is_trivially_copyable, Ts...>
template<typename ...Ts>
using has_only_trivially_copyable = has_trait_all<std::is_trivially_copyable, Ts...>
template<typename ...Ts>
using has_no_trivially_copyable = has_trait_none<std::is_trivially_copyable, Ts...>
template<typename ...Ts>
using has_any_standard_layout = has_trait_any<std::is_standard_layout, Ts...>
template<typename ...Ts>
using has_only_standard_layout = has_trait_all<std::is_standard_layout, Ts...>
template<typename ...Ts>
using has_no_standard_layout = has_trait_none<std::is_standard_layout, Ts...>
template<typename ...Ts>
using has_any_empty = has_trait_any<std::is_empty, Ts...>
template<typename ...Ts>
using has_only_empty = has_trait_all<std::is_empty, Ts...>
template<typename ...Ts>
using has_no_empty = has_trait_none<std::is_empty, Ts...>
template<typename ...Ts>
using has_any_polymorphic = has_trait_any<std::is_polymorphic, Ts...>
template<typename ...Ts>
using has_only_polymorphic = has_trait_all<std::is_polymorphic, Ts...>
template<typename ...Ts>
using has_no_polymorphic = has_trait_none<std::is_polymorphic, Ts...>
template<typename ...Ts>
using has_any_abstract = has_trait_any<std::is_abstract, Ts...>
template<typename ...Ts>
using has_only_abstract = has_trait_all<std::is_abstract, Ts...>
template<typename ...Ts>
using has_no_abstract = has_trait_none<std::is_abstract, Ts...>
template<typename ...Ts>
using has_any_final = has_trait_any<std::is_final, Ts...>
template<typename ...Ts>
using has_only_final = has_trait_all<std::is_final, Ts...>
template<typename ...Ts>
using has_no_final = has_trait_none<std::is_final, Ts...>
template<typename ...Ts>
using has_any_aggregate = has_trait_any<std::is_aggregate, Ts...>
template<typename ...Ts>
using has_only_aggregate = has_trait_all<std::is_aggregate, Ts...>
template<typename ...Ts>
using has_no_aggregate = has_trait_none<std::is_aggregate, Ts...>
template<typename ...Ts>
using has_any_signed = has_trait_any<std::is_signed, Ts...>
template<typename ...Ts>
using has_only_signed = has_trait_all<std::is_signed, Ts...>
template<typename ...Ts>
using has_no_signed = has_trait_none<std::is_signed, Ts...>
template<typename ...Ts>
using has_any_unsigned = has_trait_any<std::is_unsigned, Ts...>
template<typename ...Ts>
using has_only_unsigned = has_trait_all<std::is_unsigned, Ts...>
template<typename ...Ts>
using has_no_unsigned = has_trait_none<std::is_unsigned, Ts...>
template<typename ...Ts>
using has_any_bounded_array = has_trait_any<std::is_bounded_array, Ts...>
template<typename ...Ts>
using has_only_bounded_array = has_trait_all<std::is_bounded_array, Ts...>
template<typename ...Ts>
using has_no_bounded_array = has_trait_none<std::is_bounded_array, Ts...>
template<typename ...Ts>
using has_any_unbounded_array = has_trait_any<std::is_unbounded_array, Ts...>
template<typename ...Ts>
using has_only_unbounded_array = has_trait_all<std::is_unbounded_array, Ts...>
template<typename ...Ts>
using has_no_unbounded_array = has_trait_none<std::is_unbounded_array, Ts...>
template<typename T>
using remove_std_function_t = typename remove_std_function_type<T>::type
template<typename T>
using element_t = typename element_type<T>::type
template<typename T>
using is_pointer = is_ptr_type<T>
template<typename T>
using remove_ptr_type_t = typename remove_ptr_type<T>::type
template<typename T>
using remove_pointer_t = remove_ptr_type_t<T>
template<size_t BIT_COUNT, typename DEFAULT = void>
using uint_bit_count_t = typename uint_bit_count<BIT_COUNT, DEFAULT>::type
template<size_t NUM_STATES>
using min_uint_type = decltype(StateBitCount<NUM_STATES>())
template<size_t BIT_COUNT, typename DEFAULT = void>
using int_bit_count_t = typename int_bit_count<BIT_COUNT, DEFAULT>::type
template<typename T, typename MATCH_T>
using match_const_t = typename match_const<T, MATCH_T>::type
template<typename ...Variadics>
using variadic_concat_t = typename variadic_concat<Variadics...>::type
template<typename Variadic, template<typename> class Filter>
using variadic_filter_t = typename variadic_filter<Variadic, Filter>::type
template<typename Variadic, template<typename, typename> class ...Cmp>
using variadic_remove_duplicates_t = typename variadic_remove_duplicates<Variadic, Cmp...>::type
template<template<typename, typename> class Cmp, typename ...U>
using variadic_union_t = typename variadic_union<Cmp, U...>::type
template<template<typename, typename> class Cmp, typename ...U>
using variadic_intersection_t = typename variadic_intersection<Cmp, U...>::type

Functions

template<typename T>
constexpr bool is_ptr_type_v()
template<typename T>
constexpr bool is_ptr_type_v(const T&)
template<typename T>
auto &remove_ptr_value(T &value)

Convert a value to a non-pointer if and only if it is one.

template<size_t NUM_STATES>
static constexpr auto StateBitCount()

Variables

template<typename Needle, typename Haystack, template<typename, typename> class ...Cmp>
constexpr bool variadic_contains_v = {variadic_contains<Needle, Haystack, Cmp...>::value}
template<typename Needle, typename Haystack, template<typename, typename> class ...Cmp>
static constexpr auto variadic_index_of_v = {variadic_index_of<Needle, Haystack, Cmp...>::value}
template<template<typename...> typename TRAIT, typename ...Ts>
struct has_trait_any : public std::false_type
#include <type_traits.hpp>

Type trait framework for working with whole TYPE PACKS.

template<template<typename...> typename TRAIT, typename T, typename ...EXTRA_Ts>
struct has_trait_any<TRAIT, T, EXTRA_Ts...> : public std::bool_constant<TRAIT<T>::value || has_trait_any<TRAIT, EXTRA_Ts...>::value>
#include <type_traits.hpp>
template<template<typename...> typename TRAIT, typename ...Ts>
struct has_trait_all : public std::true_type
#include <type_traits.hpp>
template<template<typename...> typename TRAIT, typename T, typename ...EXTRA_Ts>
struct has_trait_all<TRAIT, T, EXTRA_Ts...> : public std::bool_constant<TRAIT<T>::value && has_trait_all<TRAIT, EXTRA_Ts...>::value>
#include <type_traits.hpp>
template<template<typename...> typename TRAIT, typename ...Ts>
struct has_trait_none : public std::negate<has_trait_any<TRAIT, Ts...>>
#include <type_traits.hpp>
template<typename T>
struct remove_std_function_type
#include <type_traits.hpp>

Convert std::function to base function type.

Public Types

using type = T
template<typename T>
struct remove_std_function_type<std::function<T>>
#include <type_traits.hpp>

Public Types

using type = T
template<typename T>
struct element_type
#include <type_traits.hpp>

Public Types

using type = T
template<template<typename...> class TMPL, typename T>
struct element_type<TMPL<T>>
#include <type_traits.hpp>

Public Types

using type = T
template<typename>
struct is_ptr_type : public std::false_type
#include <type_traits.hpp>
template<typename T>
struct is_ptr_type<T*> : public std::true_type
#include <type_traits.hpp>
template<typename T>
struct is_ptr_type<T*const> : public std::true_type
#include <type_traits.hpp>
template<typename T>
struct is_ptr_type<Ptr<T>> : public std::true_type
#include <type_traits.hpp>
template<typename T>
struct remove_ptr_type
#include <type_traits.hpp>

Public Types

using type = T
template<typename T>
struct remove_ptr_type<T*>
#include <type_traits.hpp>

Public Types

using type = T
template<typename T>
struct remove_ptr_type<T*const>
#include <type_traits.hpp>

Public Types

using type = const T
template<typename T>
struct remove_ptr_type<Ptr<T>>
#include <type_traits.hpp>

Public Types

using type = T
template<size_t BIT_COUNT, typename DEFAULT = void>
struct uint_bit_count
#include <type_traits.hpp>

Figure out which type is an unsigned integer with a specified number of bits.

Public Types

using type = DEFAULT
template<>
struct uint_bit_count<8>
#include <type_traits.hpp>

Public Types

using type = uint8_t
template<>
struct uint_bit_count<16>
#include <type_traits.hpp>

Public Types

using type = uint16_t
template<>
struct uint_bit_count<32>
#include <type_traits.hpp>

Public Types

using type = uint32_t
template<>
struct uint_bit_count<64>
#include <type_traits.hpp>

Public Types

using type = uint64_t
template<size_t BIT_COUNT, typename DEFAULT = void>
struct int_bit_count
#include <type_traits.hpp>

Figure out which type is an integer with a specified number of bits.

Public Types

using type = DEFAULT
template<>
struct int_bit_count<8>
#include <type_traits.hpp>

Public Types

using type = int8_t
template<>
struct int_bit_count<16>
#include <type_traits.hpp>

Public Types

using type = int16_t
template<>
struct int_bit_count<32>
#include <type_traits.hpp>

Public Types

using type = int32_t
template<>
struct int_bit_count<64>
#include <type_traits.hpp>

Public Types

using type = int64_t
template<typename T, typename MATCH_T>
struct match_const
#include <type_traits.hpp>

Match the constness of another type.

Public Types

using type = std::remove_const_t<T>
template<typename T, typename MATCH_T>
struct match_const<T, const MATCH_T>
#include <type_traits.hpp>

Public Types

using type = std::add_const_t<T>
template<typename T1, typename T2>
struct ptr_pair
#include <type_traits.hpp>

Public Static Functions

static inline constexpr bool Same()
static inline constexpr bool SameBase()
static inline bool ConvertOK(T1 *ptr)
template<typename T>
struct ptr_pair<T, T>
#include <type_traits.hpp>

Public Static Functions

static inline constexpr bool Same()
static inline constexpr bool SameBase()
static inline constexpr bool ConvertOK(T*)
template<typename T>
struct ptr_pair<T, const T>
#include <type_traits.hpp>

Public Static Functions

static inline constexpr bool Same()
static inline constexpr bool SameBase()
static inline constexpr bool ConvertOK(T*)
template<typename T>
struct ptr_pair<const T, T>
#include <type_traits.hpp>

Public Static Functions

static inline constexpr bool Same()
static inline constexpr bool SameBase()
static inline constexpr bool ConvertOK(T*)
template<typename Needle, template<typename...> class Variadic, typename ...U, template<typename, typename> class Cmp>
struct variadic_contains<Needle, Variadic<U...>, Cmp> : public __impl_variadics_type_traits::variadic_contains<Needle, __impl_variadics_type_traits::pack<U...>, Cmp>
#include <type_traits.hpp>
template<template<typename...> class Variadic, class ...A, class ...Rest>
struct variadic_concat<Variadic<A...>, Rest...>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, typename __impl_variadics_type_traits::variadic_concat<Variadic, __impl_variadics_type_traits::pack<__impl_variadics_type_traits::pack<A...>, Rest...>>::type>
template<template<typename...> class Variadic, typename ...U, template<typename> class Filter>
struct variadic_filter<Variadic<U...>, Filter>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, typename __impl_variadics_type_traits::variadic_filter<__impl_variadics_type_traits::pack<>, __impl_variadics_type_traits::pack<U...>, Filter>::type>
template<template<typename...> class Variadic, typename ...U, template<typename, typename> class Cmp>
struct variadic_remove_duplicates<Variadic<U...>, Cmp>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, typename __impl_variadics_type_traits::variadic_remove_duplicates<__impl_variadics_type_traits::pack<>, __impl_variadics_type_traits::pack<U...>, Cmp>::type>
template<template<typename...> class Variadic, template<typename, typename> class Cmp, typename ...U>
struct variadic_union<Cmp, Variadic<U...>>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, variadic_remove_duplicates_t<__impl_variadics_type_traits::pack<U...>, Cmp>>
template<template<typename...> class Variadic, template<typename, typename> class Cmp, typename ...U0, typename U1, typename ...U>
struct variadic_union<Cmp, Variadic<U0...>, U1, U...>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, typename __impl_variadics_type_traits::variadic_union<Cmp, __impl_variadics_type_traits::pack<U0...>, __impl_variadics_type_traits::ToPackType<Variadic, U1>, __impl_variadics_type_traits::ToPackType<Variadic, U>...>::type>
template<template<typename...> class Variadic, template<typename, typename> class Cmp, typename ...U>
struct variadic_intersection<Cmp, Variadic<U...>>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, variadic_remove_duplicates_t<__impl_variadics_type_traits::pack<U...>, Cmp>>
template<template<typename...> class Variadic, template<typename, typename> class Cmp, typename ...U0, typename U1, typename ...U>
struct variadic_intersection<Cmp, Variadic<U0...>, U1, U...>
#include <type_traits.hpp>

Public Types

using type = __impl_variadics_type_traits::FromPackType<Variadic, typename __impl_variadics_type_traits::variadic_intersection<Cmp, __impl_variadics_type_traits::pack<U0...>, __impl_variadics_type_traits::ToPackType<Variadic, U1>, __impl_variadics_type_traits::ToPackType<Variadic, U>...>::type>
template<typename Needle, template<typename...> class Haystack, typename ...U, template<typename, typename> class Cmp>
struct variadic_index_of<Needle, Haystack<U...>, Cmp> : public __impl_variadics_type_traits::variadic_index_of<0, Needle, __impl_variadics_type_traits::pack<U...>, Cmp>
#include <type_traits.hpp>