524 lines
16 KiB
C++
524 lines
16 KiB
C++
|
#pragma once
|
||
|
|
#ifndef __FILE_Detail_CP_Typen_Hpp
|
||
|
|
#define __FILE_Detail_CP_Typen_Hpp
|
||
|
|
|
||
|
|
#include "detail/CP/CHash.hpp"
|
||
|
|
|
||
|
|
template <typename Base, typename Derived> constexpr bool TIsBaseOf = std::is_base_of_v<Base, Derived>;
|
||
|
|
|
||
|
|
template <typename A, typename B> constexpr bool TAreSame = std::is_same_v<A, B>;
|
||
|
|
|
||
|
|
namespace Internal
|
||
|
|
{
|
||
|
|
template<typename IndexType, IndexType Index, typename... Types> struct TConditionalTool
|
||
|
|
{
|
||
|
|
|
||
|
|
};
|
||
|
|
template<int Index, typename First, typename... Types>
|
||
|
|
struct TConditionalTool<int, Index, First, Types...>
|
||
|
|
{
|
||
|
|
using Type = typename TConditionalTool<int, Index - 1, Types...>::Type;
|
||
|
|
};
|
||
|
|
template<typename First, typename... Types>
|
||
|
|
struct TConditionalTool<int, 0, First, Types...>
|
||
|
|
{
|
||
|
|
using Type = First;
|
||
|
|
};
|
||
|
|
template<typename First>
|
||
|
|
struct TConditionalTool<int, 0, First>
|
||
|
|
{
|
||
|
|
using Type = First;
|
||
|
|
};
|
||
|
|
template<bool Pr, typename First, typename Second>
|
||
|
|
struct TConditionalTool<bool, Pr, First, Second>
|
||
|
|
{
|
||
|
|
using Type = std::conditional_t<Pr, First, Second>;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
template<bool Pr, typename First, typename Second> using TChoose = typename Internal::TConditionalTool<bool, Pr, First, Second>::Type;
|
||
|
|
template<int Index, typename... Types> using TConditional = typename Internal::TConditionalTool<int, Index, Types...>::Type;
|
||
|
|
|
||
|
|
template <typename T> using TDecay = std::decay_t<T>;
|
||
|
|
|
||
|
|
template <typename T> constexpr bool TIsP = std::is_pointer_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsC = std::is_const_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsV = std::is_volatile_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsR = std::is_reference_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsF = std::is_function_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsLR = std::is_lvalue_reference_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsRR = std::is_rvalue_reference_v<T>;
|
||
|
|
template <typename T> constexpr bool TIsCV = TIsC<T> && TIsV<T>;
|
||
|
|
template <typename T> constexpr bool TIsIt = TIsP<T> || TIsLR<decltype(*std::declval<T>())>;
|
||
|
|
template <typename T> constexpr bool TIsVoid = std::is_same_v<void, T>;
|
||
|
|
template <typename T> constexpr bool THasVirtual = std::has_virtual_destructor_v<T>;
|
||
|
|
template <typename T, typename C> constexpr bool TIsCStr = TAreSame<T, const C*>&& TAreSame<T, C*>;
|
||
|
|
|
||
|
|
template <typename T> using TRemoveP = std::remove_pointer_t<T>;
|
||
|
|
template <typename T> using TRemoveC = std::remove_const_t<T>;
|
||
|
|
template <typename T> using TRemoveV = std::remove_volatile_t<T>;
|
||
|
|
template <typename T> using TRemoveR = std::remove_reference_t<T>;
|
||
|
|
template <typename T> using TRemoveCV = std::remove_cv_t<T>;
|
||
|
|
|
||
|
|
template <bool Pr, typename T = void> using TEnableIf = std::enable_if_t<Pr, T>;
|
||
|
|
|
||
|
|
namespace Internal
|
||
|
|
{
|
||
|
|
template <typename T>
|
||
|
|
struct StringAbleTool
|
||
|
|
{
|
||
|
|
template <typename U, typename = decltype(std::to_string(std::declval<U>()))>
|
||
|
|
static constexpr bool check_std_to_string(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_std_to_string(...) { return false; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(to_string(std::declval<U>()))>
|
||
|
|
static constexpr bool check_to_string(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_to_string(...) { return false; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(std::declval<U>().ToString)>
|
||
|
|
static constexpr bool check_self_to_string(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_self_to_string(...) { return false; }
|
||
|
|
|
||
|
|
static constexpr bool Value = check_std_to_string<T>(nullptr) || check_to_string<T>(nullptr) || check_self_to_string<T>(nullptr);
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(atoi(std::declval<U>()))>
|
||
|
|
static constexpr bool check_atoi_parse(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_atoi_parse(...) { return true; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(atof(std::declval<U>()))>
|
||
|
|
static constexpr bool check_atof_parse(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_atof_parse(...) { return true; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(atol(std::declval<U>()))>
|
||
|
|
static constexpr bool check_atol_parse(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_atol_parse(...) { return true; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(atoll(std::declval<U>()))>
|
||
|
|
static constexpr bool check_atoll_parse(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_atoll_parse(...) { return true; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(from_string(std::declval<U*>(),(const char*const)nullptr,0))>
|
||
|
|
static constexpr bool check_parse_string(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_parse_string(...) { return false; }
|
||
|
|
|
||
|
|
template <typename U, typename = decltype(std::declval<U>().Parse((const char* const)nullptr, 0))>
|
||
|
|
static constexpr bool check_self_parse(U*) { return true; }
|
||
|
|
|
||
|
|
template <typename U>
|
||
|
|
static constexpr bool check_self_parse(...) { return false; }
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T> constexpr bool THasToString = Internal::StringAbleTool<T>::Value;
|
||
|
|
|
||
|
|
namespace Internal
|
||
|
|
{
|
||
|
|
template <typename From, typename To>
|
||
|
|
struct TIsConvertibleImpl
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
static uint_fast8_t Test(...);
|
||
|
|
static uint_fast16_t Test(To);
|
||
|
|
|
||
|
|
public:
|
||
|
|
enum { Value = sizeof(Test((From)std::declval<From>())) - 1 };
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename From, typename To> constexpr bool TIsConvertible = Internal::TIsConvertibleImpl<From, To>::Value;
|
||
|
|
template <typename From, typename To> constexpr bool TIsPointerConvertible = TIsConvertible<From*, To*>;
|
||
|
|
template <typename From, typename To> constexpr bool TIsReferenceConvertible = TIsConvertible<From&, To&>;
|
||
|
|
|
||
|
|
namespace Internal
|
||
|
|
{
|
||
|
|
/**
|
||
|
|
* Copies the cv-qualifiers from one type to another, e.g.:
|
||
|
|
*
|
||
|
|
* TCopyQualifiers<const T1, T2>::Type == const T2
|
||
|
|
* TCopyQualifiers<volatile T1, const T2>::Type == const volatile T2
|
||
|
|
*/
|
||
|
|
template <typename From, typename To> struct TCopyQualifiersTool { typedef To Type; };
|
||
|
|
template <typename From, typename To> struct TCopyQualifiersTool<const From, To> { typedef const To Type; };
|
||
|
|
template <typename From, typename To> struct TCopyQualifiersTool< volatile From, To> { typedef volatile To Type; };
|
||
|
|
template <typename From, typename To> struct TCopyQualifiersTool<const volatile From, To> { typedef const volatile To Type; };
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename From, typename To> using TCopyQualifiers = typename Internal::TCopyQualifiersTool<From, To>::Type;
|
||
|
|
|
||
|
|
template <typename From, typename To> constexpr bool TLosesQualifiers = !TAreSame<TCopyQualifiers<From, To>, To>;
|
||
|
|
|
||
|
|
namespace Internal
|
||
|
|
{
|
||
|
|
struct PrettyFunctionTag {};
|
||
|
|
|
||
|
|
template<typename T>
|
||
|
|
constexpr std::string_view PrettyFunction()
|
||
|
|
{
|
||
|
|
return __FUNCSIG__;
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename T, T Value>
|
||
|
|
constexpr std::string_view PrettyFunction()
|
||
|
|
{
|
||
|
|
return __FUNCSIG__;
|
||
|
|
}
|
||
|
|
|
||
|
|
constexpr size_t GetPrettyFunctionPrefix()
|
||
|
|
{
|
||
|
|
auto a = PrettyFunction<PrettyFunctionTag>();
|
||
|
|
auto b = PrettyFunction<void>();
|
||
|
|
size_t result = 0;
|
||
|
|
size_t end = std::min(a.size(), b.size());
|
||
|
|
for (; result < end; result++)
|
||
|
|
{
|
||
|
|
if (a.substr(0, result) != b.substr(0, result))
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
constexpr size_t GetPrettyFunctionSuffix()
|
||
|
|
{
|
||
|
|
auto a = PrettyFunction<PrettyFunctionTag>();
|
||
|
|
auto b = PrettyFunction<void>();
|
||
|
|
size_t result = 0;
|
||
|
|
size_t end = std::min(a.size(), b.size());
|
||
|
|
for (; result < end; result++)
|
||
|
|
{
|
||
|
|
if (a.substr(a.size() - result - 1, end) != b.substr(b.size() - result - 1, end))
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename T>
|
||
|
|
constexpr size_t GetPrettyFunctionWithValuePrefix()
|
||
|
|
{
|
||
|
|
auto a = PrettyFunction<T, static_cast<T>(0)>();
|
||
|
|
auto b = PrettyFunction<T, static_cast<T>(1)>();
|
||
|
|
size_t result = 0;
|
||
|
|
size_t end = std::min(a.size(), b.size());
|
||
|
|
for (; result < end; result++)
|
||
|
|
{
|
||
|
|
if (a.substr(0, result) != b.substr(0, result))
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename T>
|
||
|
|
constexpr size_t GetPrettyFunctionWithValueSuffix()
|
||
|
|
{
|
||
|
|
auto a = PrettyFunction<T, static_cast<T>(0)>();
|
||
|
|
auto b = PrettyFunction<T, static_cast<T>(1)>();
|
||
|
|
size_t result = 0;
|
||
|
|
size_t end = std::min(a.size(), b.size());
|
||
|
|
for (; result < end; result++)
|
||
|
|
{
|
||
|
|
if (a.substr(a.size() - result - 1, end) != b.substr(b.size() - result - 1, end))
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename T>
|
||
|
|
constexpr std::string_view SymbolNameTool()
|
||
|
|
{
|
||
|
|
auto name = PrettyFunction<T>();
|
||
|
|
name.remove_prefix(GetPrettyFunctionPrefix() - 1);
|
||
|
|
name.remove_suffix(GetPrettyFunctionSuffix());
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename T,T Value>
|
||
|
|
constexpr std::string_view ValueNameTool()
|
||
|
|
{
|
||
|
|
auto name = PrettyFunction<T, Value>();
|
||
|
|
name.remove_prefix(GetPrettyFunctionWithValuePrefix<T>() - 1);
|
||
|
|
name.remove_suffix(GetPrettyFunctionWithValueSuffix<T>());
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T> struct TraitTool
|
||
|
|
{
|
||
|
|
template<typename P, bool Derived = true> static constexpr bool Is() { return (TAreSame<T, P> || (Derived && TIsBaseOf<T, P>)); }
|
||
|
|
template<typename P, bool Derived = true> static constexpr bool Is(P) { return (TAreSame<T, P> || (Derived && TIsBaseOf<T, P>)); }
|
||
|
|
template<typename P, bool Derived = true> static constexpr bool Is(P from, T& to)
|
||
|
|
{
|
||
|
|
to = static_cast<T&>(from);
|
||
|
|
return (TAreSame<T, P> || (Derived && TIsBaseOf<T, P>));
|
||
|
|
}
|
||
|
|
static bool Is(void* ptr)
|
||
|
|
{
|
||
|
|
using TSymbol = decltype(Symbol());
|
||
|
|
return Symbol() == *reinterpret_cast<TSymbol*>(reinterpret_cast<size_t>(ptr) - sizeof(TSymbol));
|
||
|
|
}
|
||
|
|
static intptr_t Symbol()
|
||
|
|
{
|
||
|
|
static auto symbol = typeid(T).hash_code();
|
||
|
|
return (intptr_t)&symbol;
|
||
|
|
}
|
||
|
|
static T* New(void* memory, size_t capacity)
|
||
|
|
{
|
||
|
|
using TSymbol = decltype(Symbol());
|
||
|
|
constexpr auto size = sizeof(TSymbol) + sizeof(T);
|
||
|
|
if (capacity < size || memory == nullptr)
|
||
|
|
return nullptr;
|
||
|
|
char* ptr = new(memory) char[size];
|
||
|
|
auto&& head = reinterpret_cast<TSymbol&>(*ptr);
|
||
|
|
head = Symbol();
|
||
|
|
T* result = reinterpret_cast<T*>(&(ptr[sizeof(TSymbol)]));
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
static void Delete(T* ptr)
|
||
|
|
{
|
||
|
|
using TSymbol = decltype(Symbol());
|
||
|
|
*reinterpret_cast<TSymbol*>(reinterpret_cast<size_t>(ptr) - sizeof(TSymbol)) = 0;
|
||
|
|
ptr->~T();
|
||
|
|
}
|
||
|
|
static T* FirstInMemory(void* memory, size_t capacity)
|
||
|
|
{
|
||
|
|
for (char* head = (char*)memory, *end = (char*)memory + capacity; head != end; head++)
|
||
|
|
{
|
||
|
|
if (Is(head))
|
||
|
|
return (T*)head;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool WriteBinary(T* object, char* buffer, size_t capacity)
|
||
|
|
{
|
||
|
|
if (sizeof(T) + sizeof(decltype(Symbol())) > capacity)
|
||
|
|
return false;
|
||
|
|
*reinterpret_cast<decltype(Symbol())*>(&buffer[0]) = Symbol();
|
||
|
|
memcpy_s(&buffer[sizeof(decltype(Symbol()))], capacity, object, sizeof(T));
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
static bool Write(T* object, char* buffer, size_t capacity, bool is_allow_binary_write = false)
|
||
|
|
{
|
||
|
|
if constexpr (StringAbleTool<T>::check_self_to_string<T>(nullptr))
|
||
|
|
{
|
||
|
|
auto str = object->ToString();
|
||
|
|
size_t strCsize = 0;
|
||
|
|
if constexpr (TIsCStr<decltype(str), char>)
|
||
|
|
{
|
||
|
|
constexpr auto _strCsize = sizeof(decltype(*str[0]));
|
||
|
|
strCsize = _strCsize;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
constexpr auto _strCsize = sizeof(decltype(*str.begin()));
|
||
|
|
strCsize = _strCsize;
|
||
|
|
}
|
||
|
|
if (strCsize == 0)
|
||
|
|
return false;
|
||
|
|
if (str.size() * strCsize > capacity)
|
||
|
|
return false;
|
||
|
|
memcpy_s(buffer, capacity, str.c_str(), str.size() * strCsize);
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_to_string<T>(nullptr))
|
||
|
|
{
|
||
|
|
auto str = to_string(*object);
|
||
|
|
size_t strCsize = 0;
|
||
|
|
if constexpr (TIsCStr<decltype(str), char>)
|
||
|
|
{
|
||
|
|
constexpr auto _strCsize = sizeof(decltype(*str[0]));
|
||
|
|
strCsize = _strCsize;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
constexpr auto _strCsize = sizeof(decltype(*str.begin()));
|
||
|
|
strCsize = _strCsize;
|
||
|
|
}
|
||
|
|
if (strCsize == 0)
|
||
|
|
return false;
|
||
|
|
if (str.size() * strCsize > capacity)
|
||
|
|
return false;
|
||
|
|
memcpy_s(buffer, capacity, str.c_str(), str.size() * strCsize);
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_std_to_string<T>(nullptr))
|
||
|
|
{
|
||
|
|
std::string str = std::to_string(*object);
|
||
|
|
if (str.size() > capacity)
|
||
|
|
return false;
|
||
|
|
memcpy_s(buffer, capacity, str.c_str(), str.size());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (is_allow_binary_write == false)
|
||
|
|
return false;
|
||
|
|
WriteBinary(object, buffer, capacity);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
static T* ReadBinaryWithoutToken(T* object, char* buffer, size_t capacity)
|
||
|
|
{
|
||
|
|
constexpr auto offset = sizeof(decltype(Symbol()));
|
||
|
|
if (capacity > sizeof(T) + offset && *reinterpret_cast<decltype(Symbol())*>(&buffer[0]) == Symbol())
|
||
|
|
memcpy(object, &buffer[offset], capacity);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (capacity > sizeof(T))
|
||
|
|
memcpy(object, buffer, capacity);
|
||
|
|
else
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
static T* ReadBinary(void* memory, size_t capacity, char* buffer, size_t buffer_capacity)
|
||
|
|
{
|
||
|
|
constexpr auto size = sizeof(T) + sizeof(decltype(Symbol()));
|
||
|
|
if (size > buffer_capacity)
|
||
|
|
return nullptr;
|
||
|
|
if (size > capacity)
|
||
|
|
return nullptr;
|
||
|
|
if (*reinterpret_cast<decltype(Symbol())*>(&buffer[0]) != Symbol())
|
||
|
|
return nullptr;
|
||
|
|
T* object = reinterpret_cast<T*>(&buffer[sizeof(decltype(Symbol()))]);
|
||
|
|
memcpy(memory, buffer, size);
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
static bool Parse(T* object, const char* const buffer, size_t capacity)
|
||
|
|
{
|
||
|
|
if constexpr (StringAbleTool<T>::check_self_parse<T>(nullptr))
|
||
|
|
{
|
||
|
|
object->Parse(buffer, capacity);
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_parse_string<T>(nullptr))
|
||
|
|
{
|
||
|
|
from_string(object, buffer, capacity);
|
||
|
|
}
|
||
|
|
else if constexpr (TAreSame<bool, T>)
|
||
|
|
{
|
||
|
|
if (strcmp(buffer, "true") == 0)
|
||
|
|
*object = true;
|
||
|
|
else if (strcmp(buffer, "false") == 0)
|
||
|
|
*object = false;
|
||
|
|
else
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_atoll_parse<T>(nullptr))
|
||
|
|
{
|
||
|
|
*object = static_cast<T>(atoll(buffer));
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_atol_parse<T>(nullptr))
|
||
|
|
{
|
||
|
|
*object = static_cast<T>(atol(buffer));
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_atoi_parse<T>(nullptr))
|
||
|
|
{
|
||
|
|
*object = static_cast<T>(atoi(buffer));
|
||
|
|
}
|
||
|
|
else if constexpr (StringAbleTool<T>::check_atof_parse<T>(nullptr))
|
||
|
|
{
|
||
|
|
*object = static_cast<T>(atof(buffer));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
constexpr static std::string_view SymbolName()
|
||
|
|
{
|
||
|
|
return SymbolNameTool<T>();
|
||
|
|
}
|
||
|
|
template<T Value>
|
||
|
|
constexpr static std::string_view ValueName()
|
||
|
|
{
|
||
|
|
return ValueNameTool<T, Value>();
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t Hash(const T& v)
|
||
|
|
{
|
||
|
|
if constexpr (std::is_integral_v<T>)
|
||
|
|
return GetTypeHash(v);
|
||
|
|
else
|
||
|
|
return GetTypeHash(&v);
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
constexpr static uint32_t InjectTypeHash()
|
||
|
|
{
|
||
|
|
auto str = SymbolName();
|
||
|
|
return CHash(str.data());
|
||
|
|
}
|
||
|
|
public:
|
||
|
|
constexpr static int TypeHash = InjectTypeHash();
|
||
|
|
};
|
||
|
|
template <typename T> struct TraitTool<const T> : public TraitTool<T> {};
|
||
|
|
template <typename T> struct TraitTool< volatile T> : public TraitTool<T> {};
|
||
|
|
template <typename T> struct TraitTool<const volatile T> : public TraitTool<T> {};
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T> using TTrait = Internal::TraitTool<T>;
|
||
|
|
using Bool = Internal::TraitTool<bool>;
|
||
|
|
using Int = Internal::TraitTool<int>;
|
||
|
|
using Float = Internal::TraitTool<float>;
|
||
|
|
using Double = Internal::TraitTool<double>;
|
||
|
|
using Long = Internal::TraitTool<long>;
|
||
|
|
using UInt = Internal::TraitTool<unsigned int>;
|
||
|
|
using Int8 = Internal::TraitTool<int8_t>;
|
||
|
|
using Int16 = Internal::TraitTool<int16_t>;
|
||
|
|
using Int32 = Internal::TraitTool<int32_t>;
|
||
|
|
using Int64 = Internal::TraitTool<int64_t>;
|
||
|
|
using UInt8 = Internal::TraitTool<uint8_t>;
|
||
|
|
using UInt16 = Internal::TraitTool<uint16_t>;
|
||
|
|
using UInt32 = Internal::TraitTool<uint32_t>;
|
||
|
|
using UInt64 = Internal::TraitTool<uint64_t>;
|
||
|
|
using LongDouble = Internal::TraitTool<long double>;
|
||
|
|
|
||
|
|
#if !defined(nameofT)&&!defined(nameofEnum)
|
||
|
|
template <typename T> constexpr auto __Inject_nameof()
|
||
|
|
{
|
||
|
|
return TTrait<T>::SymbolName();
|
||
|
|
}
|
||
|
|
template <typename T, T Value> constexpr auto __Inject_nameof()
|
||
|
|
{
|
||
|
|
return TTrait<T>::ValueName<Value>();
|
||
|
|
}
|
||
|
|
#define nameofT(x) __Inject_nameof<x>();
|
||
|
|
#define nameofEnum(x) __Inject_nameof<decltype(x),x>();
|
||
|
|
#else
|
||
|
|
template <typename T> constexpr auto nameof()
|
||
|
|
{
|
||
|
|
return TTrait<T>::SymbolName();
|
||
|
|
}
|
||
|
|
template <typename T, T Value> constexpr auto nameof()
|
||
|
|
{
|
||
|
|
return TTrait<T>::ValueName<Value>();
|
||
|
|
}
|
||
|
|
#endif // !nameof
|
||
|
|
|
||
|
|
|
||
|
|
template <typename T> using TUnwrapped = TEnableIf<TIsIt<T>, TConditional<TIsP<T>, TRemoveP<T>, decltype(*std::declval<T>())>>;
|
||
|
|
template <typename T, typename Unwrapped = TUnwrapped<T>> decltype(auto) Unwrapping(T from)
|
||
|
|
{
|
||
|
|
return *from;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename From, typename To, bool = TIsConvertible<TUnwrapped<From, To>> || TIsConvertible<From, To>> To Cast(From data)
|
||
|
|
{
|
||
|
|
if constexpr (TIsConvertible<From, To>)
|
||
|
|
return static_cast<To>(data);
|
||
|
|
return static_cast<To>(Unwrapping(data));
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // !__FILE_Detail_CP_Typen_Hpp
|