TypeTraits.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/PrimitiveTypes.h"
 
 
namespace SC
{
namespace TypeTraits
{
// clang-format off
 
template <bool B, class T = void> struct EnableIf {};
template <class T> struct EnableIf<true, T> { using type = T; };
 
template <typename T, typename U>   struct IsSame       { static constexpr bool value = false; };
template <typename T>               struct IsSame<T, T> { static constexpr bool value = true;  };
 
template <class T> struct RemovePointer       { using type = T; };
template <class T> struct RemovePointer<T*>   { using type = T; };
template <class T> struct RemovePointer<T**>  { using type = T; };
 
template <class T> struct AddReference      { using type = T&; };
template <class T> struct AddReference<T&>  { using type = T ; };
template <class T> struct AddReference<T&&> { using type = T ; };
 
template <class T> struct AddPointer      { using type = typename RemoveReference<T>::type*; };
 
template <class T> struct RemoveConst           { using type = T;};
template <class T> struct RemoveConst<const T>  { using type = T; };
 
template <typename R>                               struct ReturnType;
template <typename R, typename... Args>             struct ReturnType<R(Args...)>       { using type = R; };
template <typename R, typename... Args>             struct ReturnType<R(*)(Args...)>    { using type = R; };
template <typename R, typename C, typename... Args> struct ReturnType<R(C::*)(Args...)> { using type = R; };
 
template <typename T> struct IsConst            { using type = T; static constexpr bool value = false; };
template <typename T> struct IsConst<const T>   { using type = T; static constexpr bool value = true;  };
 
template <typename T> struct IsTriviallyCopyable { static constexpr bool value = __is_trivially_copyable(T); };
 
template <class T> struct IsReference { static constexpr bool value = IsLValueReference<T>::value || IsRValueReference<T>::value; };
 
template <bool B, class T, class F> struct Conditional { using type = T; };
template <class T, class F>         struct Conditional<false, T, F> { using type = F; };
 
template <bool B, class T, class F> using ConditionalT = typename Conditional<B,T,F>::type;
 
template <typename U, typename T> struct SameConstnessAs { using type = typename Conditional<IsConst<U>::value, const T, T>::type; };
 
template <typename T, size_t N> constexpr auto SizeOfArray(const T (&)[N]) { return N; }
 
// clang-format on
} // namespace TypeTraits
} // namespace SC
 
// Defining a constexpr destructor is C++ 20+
#if SC_LANGUAGE_CPP_AT_LEAST_20
#define SC_LANGUAGE_CONSTEXPR_DESTRUCTOR constexpr
#else
#define SC_LANGUAGE_CONSTEXPR_DESTRUCTOR
#endif