TypeTraits.h

#pragma once
 
#ifndef PL_INCLUDING_BASICS_H
#  error "Please don't include TypeTraits.h directly, but instead include Foundation/Basics.h"
#endif
 
 
template <int v>
struct plTraitInt
{
  static constexpr int value = v;
};
 
using plTypeIsMemRelocatable = plTraitInt<2>;
using plTypeIsPod = plTraitInt<1>;
using plTypeIsClass = plTraitInt<0>;
 
using plCompileTimeTrueType = char;
using plCompileTimeFalseType = int;
 
template <bool cond>
struct plConditionToCompileTimeBool
{
  using type = plCompileTimeFalseType;
};
 
template <>
struct plConditionToCompileTimeBool<true>
{
  using type = plCompileTimeTrueType;
};
 
template <typename T>
plCompileTimeFalseType operator%(const T&, const plTypeIsPod&);
 
template <typename T>
struct plIsPodType : public plTraitInt<(sizeof(*((T*)0) % *((const plTypeIsPod*)0)) == sizeof(plCompileTimeTrueType)) ? 1 : 0>
{
};
 
template <typename T>
struct plIsPodType<T*> : public plTypeIsPod
{
};
 
template <typename T, int N>
struct plIsPodType<T[N]> : public plTypeIsPod
{
};
 
template <typename T>
plCompileTimeFalseType operator%(const T&, const plTypeIsMemRelocatable&);
 
template <typename T>
struct plGetTypeClass
  : public plTraitInt<(sizeof(*((T*)0) % *((const plTypeIsMemRelocatable*)0)) == sizeof(plCompileTimeTrueType)) ? 2 : plIsPodType<T>::value>
{
};
 
template <typename From, typename To>
struct plConversionTest
{
  static plCompileTimeTrueType Test(const To&);
  static plCompileTimeFalseType Test(...);
  static From MakeFrom();
 
  enum
  {
    exists = sizeof(Test(MakeFrom())) == sizeof(plCompileTimeTrueType),
    sameType = 0
  };
};
 
template <typename T>
struct plConversionTest<T, T>
{
  enum
  {
    exists = 1,
    sameType = 1
  };
};
 
// remapping of the 0 (not special) type to 3
template <typename T1, typename T2>
struct plGetStrongestTypeClass : public plTraitInt<(T1::value == 0 || T2::value == 0) ? 0 : PL_COMPILE_TIME_MAX(T1::value, T2::value)>
{
};
 
 
#ifdef __INTELLISENSE__
 
#  define PL_DECLARE_POD_TYPE()
 
#  define PL_DECLARE_MEM_RELOCATABLE_TYPE()
 
#  define PL_DECLARE_MEM_RELOCATABLE_TYPE_CONDITIONAL(T)
 
// \brief embed this into a class to automatically detect which type class it belongs to
// This macro is only guaranteed to work for classes / structs which don't have any constructor / destructor / assignment operator!
// As arguments you have to list the types of all the members of the class / struct.
#  define PL_DETECT_TYPE_CLASS(...)
 
#else
 
#  define PL_DECLARE_POD_TYPE()                               \
    plCompileTimeTrueType operator%(const plTypeIsPod&) const \
    {                                                         \
      return {};                                              \
    }
 
#  define PL_DECLARE_MEM_RELOCATABLE_TYPE()                              \
    plCompileTimeTrueType operator%(const plTypeIsMemRelocatable&) const \
    {                                                                    \
      return {};                                                         \
    }
 
#  define PL_DECLARE_MEM_RELOCATABLE_TYPE_CONDITIONAL(T)                                                                                       \
    typename plConditionToCompileTimeBool<plGetTypeClass<T>::value == plTypeIsMemRelocatable::value || plIsPodType<T>::value>::type operator%( \
      const plTypeIsMemRelocatable&) const                                                                                                     \
    {                                                                                                                                          \
      return {};                                                                                                                               \
    }
 
#  define PL_DETECT_TYPE_CLASS_1(T1) plGetTypeClass<T1>
#  define PL_DETECT_TYPE_CLASS_2(T1, T2) plGetStrongestTypeClass<PL_DETECT_TYPE_CLASS_1(T1), PL_DETECT_TYPE_CLASS_1(T2)>
#  define PL_DETECT_TYPE_CLASS_3(T1, T2, T3) plGetStrongestTypeClass<PL_DETECT_TYPE_CLASS_2(T1, T2), PL_DETECT_TYPE_CLASS_1(T3)>
#  define PL_DETECT_TYPE_CLASS_4(T1, T2, T3, T4) plGetStrongestTypeClass<PL_DETECT_TYPE_CLASS_2(T1, T2), PL_DETECT_TYPE_CLASS_2(T3, T4)>
#  define PL_DETECT_TYPE_CLASS_5(T1, T2, T3, T4, T5) plGetStrongestTypeClass<PL_DETECT_TYPE_CLASS_4(T1, T2, T3, T4), PL_DETECT_TYPE_CLASS_1(T5)>
#  define PL_DETECT_TYPE_CLASS_6(T1, T2, T3, T4, T5, T6) \
    plGetStrongestTypeClass<PL_DETECT_TYPE_CLASS_4(T1, T2, T3, T4), PL_DETECT_TYPE_CLASS_2(T5, T6)>
 
// \brief embed this into a class to automatically detect which type class it belongs to
// This macro is only guaranteed to work for classes / structs which don't have any constructor / destructor / assignment operator!
// As arguments you have to list the types of all the members of the class / struct.
#  define PL_DETECT_TYPE_CLASS(...)                                                                                                   \
    plCompileTimeTrueType operator%(                                                                                                  \
      const plTraitInt<PL_CALL_MACRO(PL_PP_CONCAT(PL_DETECT_TYPE_CLASS_, PL_VA_NUM_ARGS(__VA_ARGS__)), (__VA_ARGS__))::value>&) const \
    {                                                                                                                                 \
      return {};                                                                                                                      \
    }
#endif
 
#define PL_DEFINE_AS_POD_TYPE(T)             \
  template <>                                \
  struct plIsPodType<T> : public plTypeIsPod \
  {                                          \
  }
 
PL_DEFINE_AS_POD_TYPE(bool);
PL_DEFINE_AS_POD_TYPE(float);
PL_DEFINE_AS_POD_TYPE(double);
 
PL_DEFINE_AS_POD_TYPE(char);
PL_DEFINE_AS_POD_TYPE(plInt8);
PL_DEFINE_AS_POD_TYPE(plInt16);
PL_DEFINE_AS_POD_TYPE(plInt32);
PL_DEFINE_AS_POD_TYPE(plInt64);
PL_DEFINE_AS_POD_TYPE(plUInt8);
PL_DEFINE_AS_POD_TYPE(plUInt16);
PL_DEFINE_AS_POD_TYPE(plUInt32);
PL_DEFINE_AS_POD_TYPE(plUInt64);
PL_DEFINE_AS_POD_TYPE(wchar_t);
PL_DEFINE_AS_POD_TYPE(unsigned long);
PL_DEFINE_AS_POD_TYPE(long);
PL_DEFINE_AS_POD_TYPE(std::byte);
 
#define PL_IS_DERIVED_FROM_STATIC(BaseClass, DerivedClass) \
  (plConversionTest<const DerivedClass*, const BaseClass*>::exists && !plConversionTest<const BaseClass*, const void*>::sameType)
 
#define PL_IS_SAME_TYPE(TypeA, TypeB) plConversionTest<TypeA, TypeB>::sameType
 
template <typename T>
struct plTypeTraits
{
  using NonConstType = typename std::remove_const<T>::type;
 
  using NonReferenceType = typename std::remove_reference<T>::type;
 
  using NonPointerType = typename std::remove_pointer<T>::type;
 
  using NonConstReferenceType = typename std::remove_const<typename std::remove_reference<T>::type>::type;
 
  using NonReferencePointerType = typename std::remove_pointer<typename std::remove_reference<T>::type>::type;
 
  using NonConstReferencePointerType = typename std::remove_const<typename std::remove_reference<typename std::remove_pointer<T>::type>::type>::type;
};
 
#define PL_MAKE_MEMBERFUNCTION_CHECKER(functionName, checkerName)                \
  template <typename T, typename Signature>                                      \
  struct checkerName                                                             \
  {                                                                              \
    template <typename U, U>                                                     \
    struct type_check;                                                           \
    template <typename O>                                                        \
    static plCompileTimeTrueType& chk(type_check<Signature, &O::functionName>*); \
    template <typename>                                                          \
    static plCompileTimeFalseType& chk(...);                                     \
    enum                                                                         \
    {                                                                            \
      value = (sizeof(chk<T>(0)) == sizeof(plCompileTimeTrueType)) ? 1 : 0       \
    };                                                                           \
  }