type_traits.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstddef>
#include <ostream>
#include <type_traits>
 
namespace toolbox
{
 
namespace traits
{
 
// 版本检测/Version detection
#if __cplusplus >= 202002L
#  define TOOLBOX_CPP20
#elif __cplusplus >= 201703L
#  define TOOLBOX_CPP17
#elif __cplusplus >= 201402L
#  define TOOLBOX_CPP14
#elif __cplusplus >= 201103L
#  define TOOLBOX_CPP11
#endif
 
// 基本类型特征工具/Basic type traits utilities
namespace detail
{
template<typename...>
using void_t = void;
 
template<typename T, typename = void>
struct has_type_impl : std::false_type
{
};
 
template<typename T>
struct has_type_impl<T, void_t<typename T::type>> : std::true_type
{
};
 
template<typename T>
struct storage_traits
{
  // 检查类型是否可以堆分配/Check if type may be heap allocated
  static constexpr bool may_be_heap_allocated = !std::is_array_v<T>
      && (sizeof(T) > 1024
          ||  // 大对象可能需要堆分配/Large objects may be heap allocated
          std::has_virtual_destructor_v<T>
          ||  // 虚析构函数暗示动态分配/Virtual destructor implies dynamic
              // allocation
          std::is_polymorphic_v<T>);  // 多态类型通常在堆上/Polymorphic types
                                      // usually on heap
 
  // 检查类型是否必须堆分配/Check if type must be heap allocated
  static constexpr bool must_be_heap_allocated =
      std::is_abstract_v<T>;  // 抽象类必须堆分配/Abstract classes must be heap
                              // allocated
 
  // 检查类型是否可以栈分配/Check if type may be stack allocated
  static constexpr bool may_be_stack_allocated =
      !must_be_heap_allocated && std::is_object_v<T> && !std::is_abstract_v<T>;
};
}  // namespace detail
 
template<typename T>
struct type_identity
{
  using type = T;
};
 
template<typename T>
struct remove_reference
{
  using type = std::remove_reference_t<T>;
};
 
// 特定成员或方法的检测/Detection of specific members or methods
#ifdef TOOLBOX_CPP17
template<typename T, typename = void>
struct has_toString : std::false_type
{
};
 
template<typename T>
struct has_toString<T, std::void_t<decltype(std::declval<T>().toString())>>
    : std::true_type
{
};
#else
template<typename T>
struct has_toString
{
private:
  template<typename U>
  static auto test(int)
      -> decltype(std::declval<U>().toString(), std::true_type {});
 
  template<typename>
  static std::false_type test(...);
 
public:
  static constexpr bool value = decltype(test<T>(0))::value;
};
#endif
 
template<typename T>
struct remove_all_qualifiers
{
  using type =
      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
};
 
// C++17及以上的辅助别名/C++17 and above helper aliases
#ifdef TOOLBOX_CPP17
template<typename T>
using remove_all_qualifiers_t = typename remove_all_qualifiers<T>::type;
#endif
 
// 可调用对象检测/Callable detection
#ifdef TOOLBOX_CPP20
template<typename T>
concept Callable = requires(T t) { &T::operator(); };
#else
template<typename T, typename = void>
struct is_callable : std::false_type
{
};
 
template<typename T>
struct is_callable<T, std::void_t<decltype(&T::operator())>> : std::true_type
{
};
#endif
 
template<typename... Ts>
struct type_list
{
  static constexpr size_t size = sizeof...(Ts);
};
 
template<typename T>
struct function_traits;
 
template<typename R, typename... Args>
struct function_traits<R(Args...)>
{
  using return_type = R;
  static constexpr size_t arity = sizeof...(Args);
 
  template<size_t N>
  using arg_type = typename std::tuple_element<N, std::tuple<Args...>>::type;
};
 
template<typename C, typename R, typename... Args>
struct function_traits<R (C::*)(Args...)> : function_traits<R(Args...)>
{
  using class_type = C;
};
 
// SFINAE工具/SFINAE utilities
#ifdef TOOLBOX_CPP20
template<typename T>
concept HasSize = requires(T t) {
  { t.size() } -> std::convertible_to<std::size_t>;
};
 
template<typename T>
concept Printable = requires(T t, std::ostream& os) {
  { os << t } -> std::same_as<std::ostream&>;
};
#else
template<typename T, typename = void>
struct has_size : std::false_type
{
};
 
template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type
{
};
 
template<typename T>
struct is_printable
{
private:
  template<typename U>
  static auto test(int)
      -> decltype(std::declval<std::ostream&>() << std::declval<U>(),
                  std::true_type {});
 
  template<typename>
  static std::false_type test(...);
 
public:
  static constexpr bool value = decltype(test<T>(0))::value;
};
#endif
 
template<typename EnumType>
class enum_wrapper
{
  static_assert(std::is_enum<EnumType>::value,
                "Template parameter must be an enum type");
 
public:
  using underlying_type = typename std::underlying_type<EnumType>::type;
 
  constexpr enum_wrapper(EnumType value)
      : value_(value)
  {
  }
 
  constexpr operator EnumType() const { return value_; }
  constexpr auto to_underlying() const -> underlying_type
  {
    return static_cast<underlying_type>(value_);
  }
 
private:
  EnumType value_;
};
 
// 编译期类型名称/Compile-time type name
#ifdef TOOLBOX_CPP17
template<typename T>
constexpr std::string_view type_name()
{
#  if defined(__clang__)
  constexpr auto prefix = std::string_view {"[T = "};
  constexpr auto suffix = std::string_view {"]"};
  constexpr auto function = std::string_view {__PRETTY_FUNCTION__};
#  elif defined(__GNUG__)
  constexpr auto prefix = std::string_view {"with T = "};
  constexpr auto suffix = std::string_view {"]"};
  constexpr auto function = std::string_view {__PRETTY_FUNCTION__};
#  elif defined(_MSC_VER)
  constexpr auto prefix = std::string_view {"type_name<"};
  constexpr auto suffix = std::string_view {">(void)"};
  constexpr auto function = std::string_view {__FUNCSIG__};
#  else
#    error Unsupported compiler
#  endif
 
  const auto start = function.find(prefix) + prefix.size();
  const auto end = function.find(suffix);
  const auto size = end - start;
  return function.substr(start, size);
}
#endif
 
template<typename T>
struct is_heap_allocated
{
  static constexpr bool value =
      detail::storage_traits<T>::must_be_heap_allocated;
};
 
template<typename T>
struct is_stack_allocated
{
  static constexpr bool value =
      detail::storage_traits<T>::may_be_stack_allocated;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_heap_allocated_v = is_heap_allocated<T>::value;
 
template<typename T>
inline constexpr bool is_stack_allocated_v = is_stack_allocated<T>::value;
#endif
 
template<typename T>
struct is_const
{
  static constexpr bool value = std::is_const_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_const_v = is_const<T>::value;
#endif
 
template<typename T>
struct is_volatile
{
  static constexpr bool value = std::is_volatile_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_volatile_v = is_volatile<T>::value;
#endif
 
template<typename T>
struct is_const_volatile
{
  static constexpr bool value = is_const_v<T> && is_volatile_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_const_volatile_v = is_const_volatile<T>::value;
#endif
 
template<typename T>
struct is_reference
{
  static constexpr bool value = std::is_reference_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_reference_v = is_reference<T>::value;
#endif
 
template<typename T>
struct is_array
{
  static constexpr bool value = std::is_array_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_array_v = is_array<T>::value;
#endif
 
template<typename T>
struct is_function
{
  static constexpr bool value = std::is_function_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_function_v = is_function<T>::value;
#endif
 
template<typename T>
struct is_member_pointer
{
  static constexpr bool value = std::is_member_pointer_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
#endif
 
template<typename T>
struct is_pointer
{
  static constexpr bool value = std::is_pointer_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_pointer_v = is_pointer<T>::value;
#endif
 
template<typename T>
struct is_null_pointer
{
  static constexpr bool value = std::is_null_pointer_v<T>;
};
 
#ifdef TOOLBOX_CPP17
template<typename T>
inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
#endif
 
// 1. 基础：void_t 实现（C++17 提供，但习惯写出来更清晰）
template<typename...>
using void_t = void;
 
// 2. is_iterable trait：只有当 T 有 begin/end 时才是可迭代的
template<typename T, typename = void>
struct is_iterable : std::false_type
{
};
 
template<typename T>
struct is_iterable<T,
                   void_t<decltype(std::begin(std::declval<T>())),
                          decltype(std::end(std::declval<T>()))>>
    : std::true_type
{
};
 
template<typename T>
inline constexpr bool is_iterable_v = is_iterable<T>::value;
 
template<typename T, typename U = T, typename = void>
struct is_less_than_comparable : std::false_type
{
  // 空实现，表示不可比较/Empty implementation, indicates not comparable
};
 
template<typename T, typename U>
struct is_less_than_comparable<
    T,
    U,
    std::void_t<decltype(std::declval<T>() < std::declval<U>())>>
    : std::true_type
{
  // 当T和U支持<时为true/True if T and U support <
};
 
template<typename T, typename U = T>
inline constexpr bool is_less_than_comparable_v =
    is_less_than_comparable<T, U>::value;
 
template<typename T, typename U = T, typename = void>
struct is_greater_than_comparable : std::false_type
{
  // 空实现，表示不可比较/Empty implementation, indicates not comparable
};
 
template<typename T, typename U>
struct is_greater_than_comparable<
    T,
    U,
    std::void_t<decltype(std::declval<T>() > std::declval<U>())>>
    : std::true_type
{
  // 当T和U支持>时为true/True if T and U support >
};
 
template<typename T, typename U = T>
inline constexpr bool is_greater_than_comparable_v =
    is_greater_than_comparable<T, U>::value;
 
}  // namespace traits
}  // namespace toolbox