King_DuckZ/DoorKeeper
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Add a way to use typename without relying on __PRETTY_FUNCTION__

Browse source 
This is now enabled by default in doorkeeper.
This commit is contained in:
King_DuckZ 2015-06-28 01:23:01 +02:00
commit 9f9ab65ff3
8 changed files with 98 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

31
include/doorkeeper/implem/typename.inl
View file

@ -1,11 +1,18 @@
namespace dk {
#if defined(USE_MANUAL_TYPENAMES)
template <typename T>
#if defined(IS_PRETTY_FUNC_CONSTEXPR)
inline constexpr const char* manual_type_name() {
static_assert(sizeof(T) == 0, "define an overload returning a const char* name for your type T");
return nullptr;
}
#endif
template <typename T>
#if defined(IS_PRETTY_FUNC_CONSTEXPR) || defined(USE_MANUAL_TYPENAMES)
constexpr
#endif
inline HashType type_name_hash() {
#if defined(IS_PRETTY_FUNC_CONSTEXPR)
#if defined(IS_PRETTY_FUNC_CONSTEXPR) || defined(USE_MANUAL_TYPENAMES)
//static_assert(dk::tiger("a", 1, 0x01).a == 0xABF87E2EEFFBBE77ULL, "Bug in tiger hash");
//static_assert(dk::tiger("message digest", 14, 0x01).a == 0x951A2078CBF881D9ULL, "Bug in tiger hash");
@ -18,14 +25,14 @@ namespace dk {
}
template <typename T>
#if defined(IS_PRETTY_FUNC_CONSTEXPR)
#if defined(IS_PRETTY_FUNC_CONSTEXPR) || defined(USE_MANUAL_TYPENAMES)
constexpr inline sprout::string<implem::type_name_len<T>()> type_name()
#else
inline std::string type_name()
#endif
{
#if defined(__GNUC__)
# if defined(IS_PRETTY_FUNC_CONSTEXPR)
# if defined(IS_PRETTY_FUNC_CONSTEXPR) || defined(USE_MANUAL_TYPENAMES)
typedef sprout::string<implem::type_name_info<T>().len> sproutstring;
typedef sprout::string<implem::type_name_len<T>()> sproutstringret;
@ -39,9 +46,14 @@ namespace dk {
# else
std::string pf(__PRETTY_FUNCTION__);
const auto read_start = pf.find('=', pf.find('[') + 1) + 2;
# if defined(__clang__)
const std::size_t typename_end = pf.size() - 1;
# else
const auto typename_end = pf.find(';', read_start);
#endif
return pf.substr(
read_start,
pf.find(';', read_start) - read_start
typename_end - read_start
);
# endif
#else
@ -52,12 +64,17 @@ namespace dk {
}
namespace implem {
#if defined(IS_PRETTY_FUNC_CONSTEXPR)
#if defined(IS_PRETTY_FUNC_CONSTEXPR) || defined(USE_MANUAL_TYPENAMES)
template <typename T>
constexpr type_name_info<T>::type_name_info() :
# if defined(__GNUC__)
# if defined(USE_MANUAL_TYPENAMES)
len(sprout::strlen(manual_type_name<T>())),
str(manual_type_name<T>())
# else
len(sizeof(__PRETTY_FUNCTION__)),
str(__PRETTY_FUNCTION__)
# endif
# else
# error "not implemented"
# endif

21
include/doorkeeper/implem/typename_native.inl Normal file
View file

@ -0,0 +1,21 @@
#if !defined(USE_MANUAL_TYPENAMES)
# error "Only usable when USE_MANUAL_TYPENAMES is defined"
#endif
namespace dk {
template<> constexpr inline const char* manual_type_name<bool>() { return "bool"; }
template<> constexpr inline const char* manual_type_name<float>() { return "float"; }
template<> constexpr inline const char* manual_type_name<double>() { return "double"; }
template<> constexpr inline const char* manual_type_name<long double>() { return "long double"; }
template<> constexpr inline const char* manual_type_name<uint8_t>() { return "uint8_t"; }
template<> constexpr inline const char* manual_type_name<uint16_t>() { return "uint16_t"; }
template<> constexpr inline const char* manual_type_name<uint32_t>() { return "uint32_t"; }
template<> constexpr inline const char* manual_type_name<uint64_t>() { return "uint64_t"; }
template<> constexpr inline const char* manual_type_name<int8_t>() { return "int8_t"; }
template<> constexpr inline const char* manual_type_name<int16_t>() { return "int16_t"; }
template<> constexpr inline const char* manual_type_name<int32_t>() { return "int32_t"; }
template<> constexpr inline const char* manual_type_name<int64_t>() { return "int64_t"; }
template<> constexpr inline const char* manual_type_name<wchar_t>() { return "wchar_t"; }
template<> constexpr inline const char* manual_type_name<char16_t>() { return "char16_t"; }
template<> constexpr inline const char* manual_type_name<char32_t>() { return "char32_t"; }
} //namespace dk