sha512sum/nameof_module
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean-up

Browse source
This commit is contained in:
Neargye 2018-08-06 16:01:40 +05:00
parent 96995e87ce
commit ea58b9d963
3 changed files with 87 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
example/example.cpp
View file

@ -121,7 +121,7 @@ int main() {
// Type full name.
std::cout << NAMEOF_TYPE_RAW(othervar.ll) << std::endl; // Long::LL
std::cout << NAMEOF_TYPE_RAW(std::declval<const SomeClass<int>>()) << std::endl; // SomeClass<int>&&
std::cout << NAMEOF_TYPE_RAW(std::declval<const SomeClass<int>>()) << std::endl; // const SomeClass<int>&&
// Raw name.
std::cout << NAMEOF_RAW(volatile const int) << std::endl; // volatile const int

86
include/nameof.hpp
View file

@ -51,9 +51,12 @@ struct identity {
template <typename T>
struct remove_all_pointers
: std::conditional<std::is_pointer<T>::value,
remove_all_pointers<typename std::remove_pointer<T>::type>,
remove_all_pointers<typename std::remove_cv<typename std::remove_pointer<T>::type>::type>,
identity<T>>::type {};
template <typename T>
using Decay = std::remove_reference<typename std::remove_cv<typename remove_all_pointers<T>::type>::type>;
// STD like compile-time string.
class cstring final {
const char* str_;
@ -150,24 +153,14 @@ class cstring final {
};
inline constexpr bool IsLexeme(char s) noexcept {
return !((s >= '0' && s <= '9') || (s >= 'a' && s <= 'z') ||
(s >= 'A' && s <= 'Z') || s == '_');
return !((s >= '0' && s <= '9') || (s >= 'a' && s <= 'z') || (s >= 'A' && s <= 'Z') || s == '_');
}
inline constexpr cstring NameofBase(const char* name, std::size_t length) noexcept {
for (std::size_t i = length; i > 0; --i) {
if (IsLexeme(name[i - 1])) {
return {&name[i], length - i};
}
}
return {name, length};
}
inline constexpr cstring NameofTemplate(const char* name, std::size_t length, bool with_suffix) noexcept {
inline constexpr cstring NameofBase(const char* name, std::size_t length, bool with_suffix) noexcept {
std::size_t p = 0;
if(IsLexeme(name[length - 1])) {
for (std::size_t i = length, h = 0; i > 0; --i) {
if (h == 0 && (name[i - 1] == '&' || name[i - 1] == '*')) {
if (h == 0 && (IsLexeme(name[i - 1]) && name[i - 1] != '>')) {
++p;
continue;
}
@ -189,12 +182,19 @@ inline constexpr cstring NameofTemplate(const char* name, std::size_t length, bo
continue;
}
if (IsLexeme(name[i - 1]) && h == 0) {
if (h == 0) {
break;
}
}
}
for (std::size_t i = length - p; i > 0; --i) {
if (IsLexeme(name[i - 1])) {
return {&name[i], length - i - (with_suffix ? 0 : p)};
}
}
return NameofBase(name, length - (with_suffix ? 0 : p));
return {name, length - (with_suffix ? 0 : p)};
}
inline constexpr cstring NameofRaw(const char* name, std::size_t length) noexcept {
@ -206,11 +206,8 @@ inline constexpr cstring NameofRaw(const char* name, std::size_t length) noexcep
template <typename T,
typename = typename std::enable_if<!std::is_reference<T>::value &&
!std::is_void<T>::value>::type>
inline constexpr detail::cstring Nameof(const T&, const char* name, std::size_t length) noexcept {
// TODO: conditional expression is constant
return (std::is_function<T>::value || std::is_member_function_pointer<T>::value)
? detail::NameofTemplate(name, length, false)
: detail::NameofBase(name, length);
inline constexpr detail::cstring Nameof(const T&, const char* name, std::size_t length, bool with_suffix = false) noexcept {
return detail::NameofBase(name, length, with_suffix);
}
template <typename T,
@ -220,49 +217,31 @@ template <typename T,
inline constexpr detail::cstring Nameof(T&&, const char*, std::size_t) = delete;
template <typename T>
inline constexpr detail::cstring NameofType(bool full = false) noexcept {
inline constexpr detail::cstring NameofTypeRaw() noexcept {
#if defined(__clang__)
const auto function_name = __PRETTY_FUNCTION__;
const auto total_length = sizeof(__PRETTY_FUNCTION__) - 1;
constexpr auto prefix_length = sizeof("nameof::detail::cstring nameof::NameofType(bool) [T = ") - 1;
constexpr auto prefix_length = sizeof("detail::cstring nameof::NameofTypeRaw() [T = ") - 1;
constexpr auto suffix_length = sizeof("]") - 1;
#elif defined(__GNUC__)
const auto function_name = __PRETTY_FUNCTION__;
const auto total_length = sizeof(__PRETTY_FUNCTION__) - 1;
constexpr auto prefix_length = sizeof("constexpr nameof::detail::cstring nameof::NameofType(bool) [T = ") - 1;
constexpr auto prefix_length = sizeof("constexpr nameof::detail::cstring nameof::NameofTypeRaw() [with T = ") - 1;
constexpr auto suffix_length = sizeof("]") - 1;
#elif defined(_MSC_VER)
const auto function_name = __FUNCSIG__;
const auto total_length = sizeof(__FUNCSIG__) - 1;
constexpr auto prefix_length = sizeof("class nameof::detail::cstring __cdecl nameof::NameofType<") - 1;
constexpr auto suffix_length = sizeof(">(bool) noexcept") - 1;
constexpr auto prefix_length = sizeof("class nameof::detail::cstring __cdecl nameof::NameofTypeRaw<") - 1;
constexpr auto suffix_length = sizeof(">(void) noexcept") - 1;
#endif
const auto raw_type_name = detail::cstring{function_name + prefix_length, total_length - prefix_length - suffix_length};
const auto type_name = full ? raw_type_name : detail::NameofTemplate(raw_type_name.begin(), raw_type_name.length(), false);
#if defined(_MSC_VER)
constexpr auto class_length = sizeof("class") - 1;
constexpr auto struct_length = sizeof("struct") - 1;
constexpr auto enum_length = sizeof("enum") - 1;
using D = typename detail::remove_all_pointers<typename std::remove_reference<T>::type>::type;
if (!full && (std::is_class<D>::value || std::is_enum<D>::value) && (std::is_reference<T>::value || std::is_pointer<T>::value)) {
if (std::is_class<D>::value && type_name[0] == 'c' && type_name[1] == 'l' && type_name[2] == 'a' && type_name[3] == 's' && type_name[4] == 's') {
return type_name.remove_prefix(class_length);
} else if (std::is_class<D>::value && type_name[0] == 's' && type_name[1] == 't' && type_name[2] == 'r' && type_name[3] == 'u' && type_name[4] == 'c' && type_name[5] == 't') {
return type_name.remove_prefix(struct_length);
} else if(std::is_enum<D>::value && type_name[0] == 'e' && type_name[1] == 'n' && type_name[2] == 'u' && type_name[3] == 'm') {
return type_name.remove_prefix(enum_length);
}
return {function_name + prefix_length, total_length - prefix_length - suffix_length};
}
#endif
return type_name;
template <typename T, typename D = typename detail::Decay<T>::type>
inline constexpr detail::cstring NameofType() noexcept {
const auto raw_type_name = NameofTypeRaw<D>();
return detail::NameofBase(raw_type_name.begin(), raw_type_name.length(), false);
}
} // namespace nameof
@ -278,8 +257,11 @@ inline constexpr detail::cstring NameofType(bool full = false) noexcept {
// Used to obtain the simple (unqualified) string name of a variable, member, function.
#define NAMEOF(name) ::nameof::Nameof<decltype(name)>(name, #name, (sizeof(#name) / sizeof(char)) - 1)
// Used to obtain the full string name of a variable, member, function.
#define NAMEOF_FULL(name) ::nameof::Nameof<decltype(name)>(name, #name, (sizeof(#name) / sizeof(char)) - 1, true)
// Used to obtain the simple (unqualified) string name of a type.
#define NAMEOF_TYPE(name) ::nameof::NameofType<decltype(name)>(false)
#define NAMEOF_TYPE(name) ::nameof::NameofType<decltype(name)>()
// Used to obtain the raw string name of a type.
#define NAMEOF_TYPE_RAW(name) ::nameof::NameofType<decltype(name)>(true)
#define NAMEOF_TYPE_RAW(name) ::nameof::NameofTypeRaw<decltype(name)>()

46
test/test.cpp
View file

@ -50,7 +50,7 @@ template <typename T>
class SomeClass {
public:
void SomeMethod5() const {
std::cout << nameof::NameofType<T>(false) << std::endl;
std::cout << nameof::NameofType<T>() << std::endl;
}
template <typename C>
@ -75,7 +75,7 @@ Long othervar;
SomeStruct& refvar = somevar;
SomeStruct* ptrvar = &somevar;
#if (__cplusplus >= 201402L || (defined(_MSVC_LANG ) && _MSVC_LANG >= 201402L))
#if 0 && (__cplusplus >= 201402L || (defined(_MSVC_LANG ) && _MSVC_LANG >= 201402L))
// Compile-time supported by C++14.
TEST_CASE("constexpr") {
SECTION("NAMEOF") {
@ -120,10 +120,10 @@ TEST_CASE("constexpr") {
constexpr auto cx1 = NAMEOF_TYPE(a);
static_assert(cx1 == "SomeClass", "");
constexpr auto cx2 = nameof::NameofType<SomeClass<int>>(false);
constexpr auto cx2 = nameof::NameofType<SomeClass<int>>();
static_assert(cx2 == "SomeClass", "");
constexpr auto cx3 = nameof::NameofType<decltype(a)>(false);
constexpr auto cx3 = nameof::NameofType<decltype(a)>();
static_assert(cx3 == "SomeClass", "");
}
@ -131,8 +131,8 @@ TEST_CASE("constexpr") {
SomeClass<int> a;
constexpr auto cx1 = NAMEOF_TYPE_RAW(a);
constexpr auto cx2 = nameof::NameofType<SomeClass<int>>(true);
constexpr auto cx3 = nameof::NameofType<decltype(a)>(true);
constexpr auto cx2 = nameof::NameofTypeRaw<SomeClass<int>>();
constexpr auto cx3 = nameof::NameofTypeRaw<decltype(a)>();
#if defined(_MSC_VER)
static_assert(cx1 == "class SomeClass<int>", "");
@ -208,9 +208,6 @@ TEST_CASE("raw name") {
REQUIRE(NAMEOF_RAW(&SomeStruct::SomeMethod1) == "&SomeStruct::SomeMethod1");
REQUIRE(NAMEOF_RAW(&SomeStruct::SomeMethod2) == "&SomeStruct::SomeMethod2");
REQUIRE(NAMEOF_RAW(SomeMethod3) == "SomeMethod3");
REQUIRE(NAMEOF_RAW(SomeMethod4<int>) == "SomeMethod4<int>");
REQUIRE(NAMEOF_RAW(&SomeClass<int>::SomeMethod5) == "&SomeClass<int>::SomeMethod5");
REQUIRE(NAMEOF_RAW(&SomeClass<int>::SomeMethod6<int>) == "&SomeClass<int>::SomeMethod6<int>");
}
SECTION("enum") {
@ -254,7 +251,19 @@ TEST_CASE("type raw name") {
REQUIRE(NAMEOF_TYPE_RAW(Color::RED) == "enum Color");
REQUIRE(NAMEOF_TYPE_RAW(std::declval<const SomeClass<int>>()) == "const classSomeClass<int>&&");
#else
#elif defined(__clang__)
REQUIRE(NAMEOF_TYPE_RAW(somevar) == "SomeStruct");
REQUIRE(NAMEOF_TYPE_RAW(ptrvar) == "SomeStruct *");
REQUIRE(NAMEOF_TYPE_RAW(refvar) == "SomeStruct &");
REQUIRE(NAMEOF_TYPE_RAW(othervar) == "Long");
REQUIRE(NAMEOF_TYPE_RAW(othervar.ll) == "Long::LL");
REQUIRE(NAMEOF_TYPE_RAW(othervar.ll.field) == "int");
REQUIRE(NAMEOF_TYPE_RAW(Color::RED) == "Color");
REQUIRE(NAMEOF_TYPE_RAW(std::declval<const SomeClass<int>>()) == "const SomeClass<int>&&");
#elif defined(__GNUC__)
REQUIRE(NAMEOF_TYPE_RAW(somevar) == "SomeStruct");
REQUIRE(NAMEOF_TYPE_RAW(ptrvar) == "SomeStruct*");
REQUIRE(NAMEOF_TYPE_RAW(refvar) == "SomeStruct&");
@ -267,21 +276,28 @@ TEST_CASE("type raw name") {
REQUIRE(NAMEOF_TYPE_RAW(std::declval<const SomeClass<int>>()) == "const SomeClass<int> &&");
#endif
}
TEST_CASE("Spaces and Tabs ignored") {
SECTION("Spaces") {
REQUIRE(NAMEOF( somevar ) == "somevar");
REQUIRE(NAMEOF_RAW( somevar ) == "somevar");
REQUIRE(NAMEOF_TYPE( int{} ) == "int");
REQUIRE(NAMEOF_TYPE_RAW( int{} ) == "int");
REQUIRE(NAMEOF_TYPE( somevar ) == "SomeStruct");
#if defined(_MSC_VER)
REQUIRE(NAMEOF_TYPE_RAW( somevar ) == "struct SomeStruct");
#else
REQUIRE(NAMEOF_TYPE_RAW( somevar ) == "SomeStruct");
#endif
}
SECTION("Tabs") {
REQUIRE(NAMEOF( somevar ) == "somevar");
REQUIRE(NAMEOF_RAW( somevar ) == "somevar");
REQUIRE(NAMEOF_TYPE( int{} ) == "int");
REQUIRE(NAMEOF_TYPE_RAW( int{} ) == "int");
REQUIRE(NAMEOF_TYPE( somevar ) == "SomeStruct");
#if defined(_MSC_VER)
REQUIRE(NAMEOF_TYPE_RAW( somevar ) == "struct SomeStruct");
#else
REQUIRE(NAMEOF_TYPE_RAW( somevar ) == "SomeStruct");
#endif
}
}