wip v0.6.0

.appveyor.yml

@@ -19,7 +19,6 @@ build:
 environment:
   matrix:
     - GENERATOR: "Visual Studio 15 2017"
-    - GENERATOR: "Visual Studio 14 2015"
 
 before_build:
   - if exist build RMDIR /S /Q build

.travis.yml

@@ -9,50 +9,6 @@ git:
 
 matrix:
   include:
-    - os: linux
-      compiler: g++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.8
-      env:
-        - CXX_COMPILER=g++-4.8 CC_COMPILER=gcc-4.8
-
-    - os: linux
-      compiler: g++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.9
-      env:
-        - CXX_COMPILER=g++-4.9 CC_COMPILER=gcc-4.9
-
-    - os: linux
-      compiler: g++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-5
-      env:
-        - CXX_COMPILER=g++-5 CC_COMPILER=gcc-5
-
-    - os: linux
-      compiler: g++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      env:
-        - CXX_COMPILER=g++-6 CC_COMPILER=gcc-6
-
     - os: linux
       compiler: g++
       addons:
@@ -75,66 +31,6 @@ matrix:
       env:
         - CXX_COMPILER=g++-8 CC_COMPILER=gcc-8
 
-    - os: linux
-      compiler: clang++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-          packages:
-            - clang-3.6
-      env:
-        - CXX_COMPILER=clang++-3.6 CC_COMPILER=clang-3.6
-
-    - os: linux
-      compiler: clang++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-          packages:
-            - clang-3.7
-      env:
-        - CXX_COMPILER=clang++-3.7 CC_COMPILER=clang-3.7
-
-    - os: linux
-      compiler: clang++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-          packages:
-            - clang-3.8
-      env:
-        - CXX_COMPILER=clang++-3.8 CC_COMPILER=clang-3.8
-
-    - os: linux
-      compiler: clang++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-3.9
-          packages:
-            - clang-3.9
-      env:
-        - CXX_COMPILER=clang++-3.9 CC_COMPILER=clang-3.9
-
-    - os: linux
-      compiler: clang++
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-          packages:
-            - clang-4.0
-      env:
-        - CXX_COMPILER=clang++-4.0 CC_COMPILER=clang-4.0
-
     - os: linux
       compiler: clang++
       addons:

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.6)
 
-project(nameof VERSION "0.3.0" LANGUAGES CXX)
+project(nameof VERSION "0.6.0" LANGUAGES CXX)
 
 option(NAMEOF_OPT_BUILD_EXAMPLES "Build nameof examples" ON)
 option(NAMEOF_OPT_BUILD_TESTS "Build and perform nameof tests" ON)

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016, 2018 Daniil Goncharov
+Copyright (c) 2016, 2018 - 2019 Daniil Goncharov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -18,7 +18,7 @@ Before, you had to use string literals to refer to definitions, which is brittle
 
 ## Features
 
-* C++11
+* C++17
 * Header-only
 * Dependency-free
 * Compile-time
@@ -43,11 +43,10 @@ NAMEOF(person.address.zip_code) -> "zip_code"
 NAMEOF(SomeMethod<int, float>) -> "SomeMethod"
 NAMEOF_FULL(SomeMethod<int, float>) -> "SomeMethod4<int, float>"
 // Name of enum
-NAMEOF(SomeEnum::RED) -> "RED"
+auto c = Color::RED;
-auto e = SomeEnum::RED;
+NAMEOF_ENUM(c) -> "RED"
-NAMEOF_ENUM(e) -> "RED"
 // Name of type
-NAMEOF_TYPE(SomeEnum::RED) -> "SomeEnum"
+NAMEOF_TYPE(Color::RED) -> "Color"
 NAMEOF_TYPE_T(int) -> "int"
 // Name of macros
 NAMEOF(__LINE__) -> "__LINE__"
@@ -57,7 +56,7 @@ NAMEOF(__LINE__) -> "__LINE__"
 
 ```cpp
 constexpr auto cx = NAMEOF(somevar); -> "somevar"
-static_assert(cx == "somevar", "Wrong name!");
+static_assert("somevar" == cx, "Wrong name!");
 ```
 
 * Compilation check
@@ -102,6 +101,8 @@ void f() {
 
 ## Remarks
 
+* Nameof return std::string_view.
+
 * The argument expression identifies a code definition, but it is never evaluated.
 
 * If you need raw fully-qualified name, use NAMEOF_RAW().
@@ -114,24 +115,23 @@ NAMEOF_RAW(&SomeStruct::SomeMethod) -> "&SomeStruct::SomeMethod"
 * Instead of macros NAMEOF_ENUM, you can use the function nameof::NameofEnum().
 
 ```cpp
-nameof::NameofEnum(SomeEnum::RED) -> "RED"
+nameof::NameofEnum(Color::RED) -> "RED"
-auto e = SomeEnum::RED;
+auto c = Color::RED;
-nameof::NameofEnum(e) -> "RED"
+nameof::NameofEnum(c) -> "RED"
 ```
 
 * Instead of macros NAMEOF_TYPE, you can use the function nameof::NameofType<>.
 
 ```cpp
-nameof::NameofType<decltype(SomeEnum::RED)>() -> "SomeEnum"
+nameof::NameofType<decltype(Color::RED)>() -> "Color"
 nameof::NameofType<int> -> "int"
 ```
 
 * NAMEOF_ENUM does not work on the GCC.
 
 ```cpp
-// On GCC.
+auto c = Color::RED;
-auto e = SomeEnum::RED;
+NAMEOF_ENUM(c) -> "(Color)0"
-NAMEOF_ENUM(e) -> "(SomeEnum)0"
 ```
 
 * Spaces and Tabs ignored
@@ -143,7 +143,7 @@ NAMEOF(	somevar	) -> "somevar"
 
 ## Integration
 
-You should add required file [nameof.hpp](include/nameof.hpp) and switch to C++11.
+You should add required file [nameof.hpp](include/nameof.hpp).
 
 ## Compiler compatibility
 

example/CMakeLists.txt

@@ -5,12 +5,13 @@ set(OPTIONS "")
 if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
     set(CMAKE_VERBOSE_MAKEFILE ON)
     set(OPTIONS -Wall -Wextra -pedantic-errors)
-    set(OPTIONS ${OPTIONS} -std=c++11)
+    set(OPTIONS ${OPTIONS} -std=c++17)
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(OPTIONS /W4)
     if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.11)
         set(OPTIONS ${OPTIONS} /permissive-)
     endif()
+    set(OPTIONS ${OPTIONS} /std:c++17)
 endif()
 
 add_executable(example

example/example.cpp

@@ -1,7 +1,6 @@
-// nameof example
-//
 // Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-// Copyright (c) 2018 Daniil Goncharov <neargye@gmail.com>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018 - 2019 Daniil Goncharov <neargye@gmail.com>.
 //
 // Permission is hereby  granted, free of charge, to any  person obtaining a copy
 // of this software and associated  documentation files (the "Software"), to deal
@@ -50,14 +49,25 @@ void SomeMethod3() {
 
 template <typename T, typename U>
 std::string SomeMethod4(U value) {
-  return NAMEOF(SomeMethod4<T, U>) + "<" + NAMEOF_TYPE_T(T) + ", " + NAMEOF_TYPE_T(U) + ">(" + NAMEOF_TYPE_T(U) + " " + NAMEOF(value) + ")";
+  std::string s;
+  s += NAMEOF(SomeMethod4<T, U>);
+  s += "<";
+  s += NAMEOF_TYPE_T(T);
+  s += ", ";
+  s += NAMEOF_TYPE_T(U);
+  s += ">(";
+  s += NAMEOF_TYPE_T(U);
+  s += " ";
+  s += NAMEOF(value);
+  s += ")";
+  return s;
 }
 
 template <typename T>
 class SomeClass {
 public:
   void SomeMethod5() const {
-    std::cout << nameof::NameofType<T>() << std::endl;
+    std::cout << nameof::nameof_type<T>() << std::endl;
   }
 
   template <typename C>
@@ -75,7 +85,7 @@ struct Long {
   LL ll;
 };
 
-enum class Color { RED, GREEN, BLUE };
+enum class Color { RED = -10, GREEN, BLUE };
 
 SomeStruct structvar;
 Long othervar;
@@ -84,14 +94,14 @@ SomeStruct* ptrvar = &structvar;
 int main() {
   // Compile-time nameof.
   constexpr auto constexpr_work_fine = NAMEOF(structvar);
-  static_assert("structvar" == constexpr_work_fine, "");
+  static_assert("structvar" == constexpr_work_fine);
 
   // Enum name.
   std::cout << NAMEOF(Color::RED) << std::endl; // RED
-  std::cout << NAMEOF_ENUM(Color::RED) << std::endl; // RED
   auto color = Color::RED;
   std::cout << NAMEOF(color) << std::endl; // color
   std::cout << NAMEOF_ENUM(color) << std::endl; // RED
+  std::cout << nameof::nameof_enum(color) << std::endl; // RED
 
   // Variable name.
   std::cout << NAMEOF(structvar) << std::endl; // structvar

include/nameof.hpp

@@ -8,7 +8,8 @@
 // vesion 0.5.0
 //
 // Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-// Copyright (c) 2016, 2018 Daniil Goncharov <neargye@gmail.com>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2016, 2018 - 2019 Daniil Goncharov <neargye@gmail.com>.
 //
 // Permission is hereby  granted, free of charge, to any  person obtaining a copy
 // of this software and associated  documentation files (the "Software"), to deal
@@ -32,21 +33,7 @@
 
 #include <cstddef>
 #include <type_traits>
-#include <limits>
+#include <string_view>
-#include <stdexcept>
-#include <string>
-#include <ostream>
-
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304L
-#  define NAMEOF_HAS_CONSTEXPR14 1
-#endif
-
-#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 5) || defined(_MSC_VER)
-#  define NAMEOF_HAS_CONSTEXPR 1
-#  define NAMEOF_CONSTEXPR constexpr
-#else
-#  define NAMEOF_CONSTEXPR inline
-#endif
 
 #if !defined(NAMEOF_ENUM_MAX_SEARCH_DEPTH)
 #  define NAMEOF_ENUM_MAX_SEARCH_DEPTH 64
@@ -56,159 +43,22 @@ namespace nameof {
 
 namespace detail {
 
-namespace nstd {
-
 template <typename T>
 struct identity {
   using type = T;
 };
 
-} // namespace nstd
+constexpr bool is_lexeme(char s) noexcept {
-
-#if !defined(NAMEOF_HAS_CONSTEXPR14)
-constexpr int CharCompare(char lhs, char rhs) {
-  return (lhs > rhs) ? 1 : ((lhs < rhs) ? -1 : 0);
-}
-#endif
-
-constexpr int StrCompare(const char* lhs, const char* rhs, std::size_t size) {
-#if !defined(_MSC_VER) && __cplusplus >= 201703L
-  return std::char_traits<char>::compare(lhs, rhs, size);
-#elif defined(NAMEOF_HAS_CONSTEXPR14)
-  for (std::size_t i = 0; i < size; ++i) {
-    if (lhs[i] > rhs[i]) {
-      return 1;
-    }
-    if (lhs[i] < rhs[i]) {
-      return -1;
-    }
-  }
-  return 0;
-#else
-  return (size == 0) ? CharCompare(lhs[0], rhs[0])
-                     : (CharCompare(lhs[size - 1], rhs[size - 1]) == 0)
-                           ? StrCompare(lhs, rhs, size - 1)
-                           : CharCompare(lhs[size - 1], rhs[size - 1]);
-#endif
-}
-
-} // namespace detail
-
-// std::string like compile-time const char* string.
-class cstring final {
-  const char* str_;
-  std::size_t size_;
-
- public:
-  constexpr cstring(const char* str, std::size_t size, std::size_t prefix = 0, std::size_t suffix = 0) noexcept
-      : str_{str + prefix},
-        size_{size - prefix - suffix} {}
-
-  template <std::size_t N>
-  constexpr cstring(const char (&str)[N]) noexcept : cstring{str, N - 1, 0, 0} {}
-
-  constexpr cstring() noexcept : cstring{nullptr, 0, 0, 0} {}
-
-  cstring(const std::string& str) noexcept : cstring{str.data(), str.size(), 0, 0} {}
-
-  constexpr cstring(const cstring&) = default;
-
-  cstring& operator=(const cstring&) = default;
-
-  constexpr std::size_t size() const noexcept { return size_; }
-
-  constexpr std::size_t length() const noexcept { return size_; }
-
-  constexpr std::size_t max_size() const noexcept {
-    return (std::numeric_limits<std::size_t>::max)();
-  }
-
-  constexpr bool empty() const noexcept { return size_ == 0; }
-
-  constexpr const char* begin() const noexcept { return str_; }
-
-  constexpr const char* end() const noexcept { return str_ + size_; }
-
-  constexpr const char* cbegin() const noexcept { return begin(); }
-
-  constexpr const char* cend() const noexcept { return end(); }
-
-  constexpr const char& operator[](std::size_t i) const { return str_[i]; }
-
-  constexpr const char& at(std::size_t i) const {
-    return (i < size_) ? str_[i]
-                       : (throw std::out_of_range{"cstring::at"}, str_[0]);
-  }
-
-  constexpr const char& front() const { return str_[0]; }
-
-  constexpr const char& back() const { return str_[size_ - 1]; }
-
-  constexpr const char* data() const noexcept { return str_; }
-
-  constexpr cstring remove_prefix(std::size_t n) const {
-    return {str_ + n, size_ - n};
-  }
-
-  constexpr cstring add_prefix(std::size_t n) const {
-    return {str_ - n, size_ + n};
-  }
-
-  constexpr cstring remove_suffix(std::size_t n) const {
-    return {str_, size_ - n};
-  }
-
-  constexpr cstring add_suffix(std::size_t n) const {
-    return {str_, size_ + n};
-  }
-
-  constexpr cstring substr(std::size_t pos, std::size_t n) const {
-    return {str_ + pos, n};
-  }
-
-  constexpr int compare(cstring other) const {
-    return (size_ == other.size_) ? detail::StrCompare(str_, other.str_, size_)
-                                  : ((size_ > other.size_) ? 1 : -1);
-  }
-
-  friend constexpr bool operator==(cstring lhs, cstring rhs) {
-    return lhs.compare(rhs) == 0;
-  }
-
-  friend constexpr bool operator!=(cstring lhs, cstring rhs) {
-    return !(lhs == rhs);
-  }
-
-  std::string append(cstring s) const {
-    return std::string{str_, size_}.append(s.str_, s.size_);
-  }
-
-  friend std::string operator+(cstring lhs, cstring rhs) {
-    return std::string{lhs.str_, lhs.size_} + std::string{rhs.str_, rhs.size_};
-  }
-
-  friend std::ostream& operator<<(std::ostream& os, cstring str) {
-    os.write(str.str_, str.size_);
-    return os;
-  }
-
-  operator std::string() const { return std::string{str_, size_}; }
-};
-
-namespace detail {
-
-constexpr bool IsLexeme(char s) noexcept {
   return !((s >= '0' && s <= '9') || (s >= 'a' && s <= 'z') || (s >= 'A' && s <= 'Z') || s == '_');
 }
 
-constexpr bool IsBracket(char s) noexcept {
+constexpr bool is_bracket(char s) noexcept {
   return s == ')' || s == '}' || s == '>' || s == '(' || s == '{' || s == '<';
 }
 
-#if defined(NAMEOF_HAS_CONSTEXPR14)
+constexpr std::string_view pretty_name(std::string_view name, bool with_suffix) {
-constexpr cstring NameofPretty(cstring name, bool with_suffix) {
   for (std::size_t i = name.size(), h = 0, s = 0; i > 0; --i) {
-    if (h == 0 && IsLexeme(name[i - 1]) && !IsBracket(name[i - 1])) {
+    if (h == 0 && is_lexeme(name[i - 1]) && !is_bracket(name[i - 1])) {
       ++s;
       continue;
     }
@@ -224,7 +74,7 @@ constexpr cstring NameofPretty(cstring name, bool with_suffix) {
     }
 
     if (h == 0) {
-      name = name.remove_suffix(s);
+      name.remove_suffix(s);
       break;
     } else {
       ++s;
@@ -253,183 +103,121 @@ constexpr cstring NameofPretty(cstring name, bool with_suffix) {
   }
 
   for (std::size_t i = name.size() - s; i > 0; --i) {
-    if (IsLexeme(name[i - 1])) {
+    if (is_lexeme(name[i - 1])) {
-      return name.remove_prefix(i).remove_suffix(with_suffix ? 0 : s);
+      name.remove_prefix(i);
+      break;
     }
   }
+  name.remove_suffix(with_suffix ? 0 : s);
 
-  return name.remove_suffix(with_suffix ? 0 : s);
+  return name;
 }
-#else
-constexpr cstring RemoveSuffix(cstring name, std::size_t h = 0) {
-  return (h == 0 && IsLexeme(name.back()) && !IsBracket(name.back()))
-             ? RemoveSuffix(name.remove_suffix(1), h)
-             : (name.back() == ')' || name.back() == '}')
-                   ? RemoveSuffix(name.remove_suffix(1), h + 1)
-                   : (name.back() == '(' || name.back() == '{')
-                         ? RemoveSuffix(name.remove_suffix(1), h - 1)
-                         : (h == 0) ? name
-                                    : RemoveSuffix(name.remove_suffix(1), h);
-}
-
-constexpr std::size_t FindSuffix(cstring name, std::size_t h = 0, std::size_t s = 0) {
-  return (name[name.size() - 1 - s] == '>')
-             ? FindSuffix(name, h + 1, s + 1)
-             : (name[name.size() - 1 - s] == '<')
-                   ? FindSuffix(name, h - 1, s + 1)
-                   : (h == 0) ? s : FindSuffix(name, h, s + 1);
-}
-
-constexpr cstring RemovePrefix(cstring name, const std::size_t p = 0) {
-  return p == name.size() ? name : IsLexeme(name[name.size() - 1 - p])
-                                       ? name.remove_prefix(name.size() - p)
-                                       : RemovePrefix(name, p + 1);
-}
-
-constexpr cstring NameofPrettyImpl1(cstring name, std::size_t s, bool with_suffix) {
-  return RemovePrefix(name.remove_suffix(s)).add_suffix(with_suffix ? s : 0);
-}
-
-constexpr cstring NameofPrettyImpl(cstring name, bool with_suffix) {
-  return NameofPrettyImpl1(name, FindSuffix(name), with_suffix);
-}
-
-constexpr cstring NameofPretty(cstring name, bool with_suffix) {
-  return NameofPrettyImpl(RemoveSuffix(name), with_suffix);
-}
-#endif
-
-#if defined(_MSC_VER)
-constexpr cstring RemoveSpaceSuffix(cstring name) {
-  return (name.back() == ' ') ? RemoveSpaceSuffix(name.remove_suffix(1)) : name;
-}
-
-constexpr cstring RemoveClassPrefix(cstring name) {
-  return (name.size() > sizeof("class") && name[0] == 'c' && name[1] == 'l' &&
-          name[2] == 'a' && name[3] == 's' && name[4] == 's' && name[5] == ' ')
-             ? name.remove_prefix(sizeof("class"))
-             : name;
-}
-
-constexpr cstring RemoveEnumPrefix(cstring name) {
-  return (name.size() > sizeof("enum") && name[0] == 'e' && name[1] == 'n' &&
-          name[2] == 'u' && name[3] == 'm' && name[4] == ' ')
-             ? name.remove_prefix(sizeof("enum"))
-             : name;
-}
-
-constexpr cstring RemoveStructPrefix(cstring name) {
-  return (name.size() > sizeof("struct") && name[0] == 's' && name[1] == 't' &&
-          name[2] == 'r' && name[3] == 'u' && name[4] == 'c' &&
-          name[5] == 't' && name[6] == ' ')
-             ? name.remove_prefix(sizeof("struct"))
-             : name;
-}
-
-constexpr cstring NameofTypePretty(cstring name) {
-  return RemoveClassPrefix(RemoveStructPrefix(RemoveEnumPrefix(RemoveSpaceSuffix(name))));
-}
-#elif defined(__clang__) || defined(__GNUC__)
-constexpr cstring NameofTypePretty(const char* str, std::size_t size, std::size_t prefix, std::size_t suffix) {
-  return {str, size, prefix, suffix + ((str[size - suffix - 1] == ' ') ? 1 : 0)};
-}
-#endif
 
 template <typename T>
-NAMEOF_CONSTEXPR int NameofEnumImpl1() {
+constexpr int nameof_enum_impl_() {
 #if defined(__clang__)
-  return sizeof(__PRETTY_FUNCTION__) - sizeof("int nameof::detail::NameofEnumImpl1() [T = ") - sizeof("]") + 1;
+  return sizeof(__PRETTY_FUNCTION__) - sizeof("int nameof::detail::nameof_enum_impl_() [T = ") - sizeof("]") + 1;
 #elif defined(__GNUC__)
-#  if defined(NAMEOF_HAS_CONSTEXPR)
+  return sizeof(__PRETTY_FUNCTION__) - sizeof("constexpr int nameof::detail::nameof_enum_impl_() [with T = ") - sizeof("]") + 1;
-  return sizeof(__PRETTY_FUNCTION__) - sizeof("constexpr int nameof::detail::NameofEnumImpl1() [with T = ") - sizeof("]") + 1;
-#  else
-  return sizeof(__PRETTY_FUNCTION__) - sizeof("int nameof::detail::NameofEnumImpl1() [with T = ") - sizeof("]") + 1;
-#  endif
 #elif defined(_MSC_VER)
-  return sizeof(__FUNCSIG__) - sizeof("int __cdecl nameof::detail::NameofEnumImpl1<") - sizeof(">(void)") + 1;
+  return sizeof(__FUNCSIG__) - sizeof("int __cdecl nameof::detail::nameof_enum_impl_<") - sizeof(">(void)") + 1;
 #else
   return 0;
 #endif
 }
 
 template <typename T, T V>
-NAMEOF_CONSTEXPR cstring NameofEnumImpl2() {
+constexpr std::string_view nameof_enum_impl() {
 #if defined(__clang__)
-  return {__PRETTY_FUNCTION__,
+  const auto str = __PRETTY_FUNCTION__;
-          sizeof(__PRETTY_FUNCTION__) - 1,
+  const auto size = sizeof(__PRETTY_FUNCTION__) - 1;
-          sizeof("nameof::cstring nameof::detail::NameofEnumImpl2() [T = ") + NameofEnumImpl1<T>() + sizeof("; V = ") - 2,
+  const auto prefix = sizeof("std::string_view nameof::detail::nameof_enum_impl() [T = ") + nameof_enum_impl_<T>() + sizeof("; V = ") - 2;
-          sizeof("]") - 1};
+  const auto suffix = sizeof("]") - 1;
+  return {str + prefix, size - prefix - suffix};
 #elif defined(__GNUC__)
-  return {__PRETTY_FUNCTION__,
+  const auto str = __PRETTY_FUNCTION__;
-          sizeof(__PRETTY_FUNCTION__) - 1,
+  const auto size = sizeof(__PRETTY_FUNCTION__) - 1;
-#  if defined(NAMEOF_HAS_CONSTEXPR)
+  const auto prefix = sizeof("constexpr std::string_view nameof::detail::nameof_enum_impl() [with T = ") + nameof_enum_impl_<T>() + sizeof("; V = ");
-          sizeof("constexpr nameof::cstring nameof::detail::NameofEnumImpl2() [with T = ") + NameofEnumImpl1<T>() + sizeof("; T V = ") - 2,
+  const auto suffix = sizeof("; std::string_view = std::basic_string_view<char>]") - 1;
-#  else
+  return {str + prefix, size - prefix - suffix};
-          sizeof("nameof::cstring nameof::detail::NameofEnumImpl2() [with T = ") + NameofEnumImpl1<T>() + sizeof("; T V = ") - 2,
-#  endif
-          sizeof("]") - 1};
 #elif defined(_MSC_VER)
-  return {__FUNCSIG__,
+  const auto str = __FUNCSIG__;
-          sizeof(__FUNCSIG__) - 1,
+  const auto size = sizeof(__FUNCSIG__) - 1;
-          sizeof("class nameof::cstring __cdecl nameof::detail::NameofEnumImpl2<") + NameofEnumImpl1<T>(),
+  const auto prefix = sizeof("class std::basic_string_view<char,struct std::char_traits<char> > __cdecl nameof::detail::nameof_enum_impl<") + nameof_enum_impl_<T>();
-          sizeof(">(void)") - 1};
+  const auto suffix = sizeof(">(void)") - 1;
+  return {str + prefix, size - prefix - suffix};
 #else
   return {};
 #endif
 }
 
 template <typename T, int I>
-struct NameofEnumImpl {
+struct nameof_enum_t {
-  NAMEOF_CONSTEXPR cstring operator()(int value) const {
+  constexpr std::string_view operator()(int value) const {
     return (value - I == 0)
-               ? NameofEnumImpl2<T, T(I)>()
+               ? nameof_enum_impl<T, T(I)>()
                : (value - I == 1)
-                     ? NameofEnumImpl2<T, T(I + 1)>()
+                     ? nameof_enum_impl<T, T(I + 1)>()
                      : (value - I == 2)
-                           ? NameofEnumImpl2<T, T(I + 2)>()
+                           ? nameof_enum_impl<T, T(I + 2)>()
                            : (value - I == 3)
-                                 ? NameofEnumImpl2<T, T(I + 3)>()
+                                 ? nameof_enum_impl<T, T(I + 3)>()
                                  : (value - I == 4)
-                                       ? NameofEnumImpl2<T, T(I + 4)>()
+                                       ? nameof_enum_impl<T, T(I + 4)>()
                                        : (value - I == 5)
-                                             ? NameofEnumImpl2<T, T(I + 5)>()
+                                             ? nameof_enum_impl<T, T(I + 5)>()
                                              : (value - I == 6)
-                                                   ? NameofEnumImpl2<T, T(I + 6)>()
+                                                   ? nameof_enum_impl<T, T(I + 6)>()
                                                    : (value - I == 7)
-                                                         ? NameofEnumImpl2<T, T(I + 7)>()
+                                                         ? nameof_enum_impl<T, T(I + 7)>()
-                                                         : NameofEnumImpl<T, I + 8>{}(value);
+                                                         : nameof_enum_t<T, I + 8>{}(value);
   }
 };
 
 template <typename T>
-struct NameofEnumImpl<T, NAMEOF_ENUM_MAX_SEARCH_DEPTH> {
+struct nameof_enum_t<T, NAMEOF_ENUM_MAX_SEARCH_DEPTH> {
-  NAMEOF_CONSTEXPR cstring operator()(int) const { return {}; }
+  constexpr std::string_view operator()(int) const { return {"nameof_enum::out_of_range"}; }
 };
 
-template <typename T>
+constexpr std::string_view nameof_type_impl_(std::string_view name) {
-NAMEOF_CONSTEXPR cstring NameofType() {
+#if defined(_MSC_VER)
-#if defined(__clang__)
+  if (name.size() > sizeof("enum") && name[0] == 'e' && name[1] == 'n' && name[2] == 'u' && name[3] == 'm' && name[4] == ' ') {
-  return NameofTypePretty(
+    name.remove_prefix(sizeof("enum"));
-      __PRETTY_FUNCTION__,
+  }
-      sizeof(__PRETTY_FUNCTION__) - 1,
+  if (name.size() > sizeof("class") && name[0] == 'c' && name[1] == 'l' && name[2] == 'a' && name[3] == 's' && name[4] == 's' && name[5] == ' ') {
-      sizeof("nameof::cstring nameof::detail::NameofType() [T = nameof::detail::nstd::identity<") - 1,
+    name.remove_prefix(sizeof("class"));
-      sizeof(">]") - 1);
+  }
-#elif defined(__GNUC__)
+  if (name.size() > sizeof("struct") && name[0] == 's' && name[1] == 't' && name[2] == 'r' && name[3] == 'u' && name[4] == 'c' && name[5] == 't' && name[6] == ' ') {
-  return NameofTypePretty(
+    name.remove_prefix(sizeof("struct"));
-      __PRETTY_FUNCTION__,
+  }
-      sizeof(__PRETTY_FUNCTION__) - 1,
-#  if defined(NAMEOF_HAS_CONSTEXPR)
-      sizeof("constexpr nameof::cstring nameof::detail::NameofType() [with T = nameof::detail::nstd::identity<") - 1,
-#  else
-      sizeof("nameof::cstring nameof::detail::NameofType() [with T = nameof::detail::nstd::identity<") - 1,
 #endif
-      sizeof(">]") - 1);
+  while (name.back() == ' ') {
+    name.remove_suffix(1);
+  }
+
+  return name;
+}
+
+template <typename T>
+constexpr std::string_view nameof_type_impl() {
+#if defined(__clang__)
+  const auto str = __PRETTY_FUNCTION__;
+  const auto size = sizeof(__PRETTY_FUNCTION__) - 1;
+  const auto prefix = sizeof("std::string_view nameof::detail::nameof_type_impl() [T = nameof::detail::identity<") - 1;
+  const auto suffix = sizeof(">]") - 1;
+  return nameof_type_impl_({str + prefix, size - prefix - suffix});
+#elif defined(__GNUC__)
+  const auto str = __PRETTY_FUNCTION__;
+  const auto size = sizeof(__PRETTY_FUNCTION__) - 1;
+  const auto prefix = sizeof("constexpr std::string_view nameof::detail::nameof_type_impl() [with T = nameof::detail::identity<") - 1;
+  const auto suffix = sizeof(">; std::string_view = std::basic_string_view<char>]") - 1;
+  return nameof_type_impl_({str + prefix, size - prefix - suffix});
 #elif defined(_MSC_VER)
-  return NameofTypePretty(
+  const auto str = __FUNCSIG__;
-      {__FUNCSIG__,
+  const auto size = sizeof(__FUNCSIG__) - 1;
-      sizeof(__FUNCSIG__) - 1,
+  const auto prefix = sizeof("class std::basic_string_view<char,struct std::char_traits<char> > __cdecl nameof::detail::nameof_type_impl<struct nameof::detail::identity<") - 1;
-      sizeof("class nameof::cstring __cdecl nameof::detail::NameofType<struct nameof::detail::nstd::identity<") - 1,
+  const auto suffix = sizeof(">>(void)") - 1;
-      sizeof(">>(void)") - 1});
+  return nameof_type_impl_({str + prefix, size - prefix - suffix});
 #else
   return {};
 #endif
@@ -439,49 +227,48 @@ NAMEOF_CONSTEXPR cstring NameofType() {
 
 template <typename T,
           typename = typename std::enable_if<!std::is_reference<T>::value>::type>
-constexpr cstring Nameof(const char* name, std::size_t size, bool with_suffix = false) {
+constexpr std::string_view nameof(std::string_view name, bool with_suffix = false) {
-  return detail::NameofPretty({name, size}, with_suffix);
+  return detail::pretty_name(name, with_suffix);
 }
 
 template <typename T,
-          typename D = typename std::decay<T>::type,
+          typename = typename std::enable_if<std::is_enum<typename std::decay<T>::type>::value>::type>
-          typename U = typename std::underlying_type<D>::type,
+constexpr std::string_view nameof_enum(T value) {
-          typename S = typename std::is_signed<U>::type,
+  constexpr auto s = std::is_signed<typename std::underlying_type<typename std::decay<T>::type>::type>::value;
-          typename = typename std::enable_if<std::is_enum<D>::value>::type>
+  const auto name = detail::nameof_enum_t<typename std::decay<T>::type, s ? -NAMEOF_ENUM_MAX_SEARCH_DEPTH : 0>{}(static_cast<int>(value));
-NAMEOF_CONSTEXPR cstring NameofEnum(D value) {
 #if defined(__clang__) || defined(_MSC_VER)
-  return detail::NameofPretty(
+  return detail::pretty_name(name, false);
-      detail::NameofEnumImpl<D, S::value ? -NAMEOF_ENUM_MAX_SEARCH_DEPTH : 0>{}(static_cast<int>(value)),
-      false);
 #elif defined(__GNUC__)
-  return detail::NameofEnumImpl<D, S::value ? -NAMEOF_ENUM_MAX_SEARCH_DEPTH : 0>{}(static_cast<int>(value));
+  return name;
 #else
   return {};
 #endif
 }
 
-template <typename T, typename D = detail::nstd::identity<T>>
+template <typename T>
-NAMEOF_CONSTEXPR cstring NameofType() {
+constexpr std::string_view nameof_type() {
-  return true ? detail::NameofType<D>() : detail::NameofType<D>();
+  return detail::nameof_type_impl<detail::identity<T>>();
 }
 
 template <typename T>
-constexpr cstring NameofRaw(const char* name, std::size_t size) {
+constexpr std::string_view nameof_raw(std::string_view name) {
-  return {name, size};
+  return name;
 }
 
 } // namespace nameof
 
 // Used to obtain the simple (unqualified) string name of a variable, member, function, enum, macros.
-#define NAMEOF(...) ::nameof::Nameof<decltype(__VA_ARGS__)>(#__VA_ARGS__, (sizeof(#__VA_ARGS__) / sizeof(char)) - 1, false)
+#define NAMEOF(...) ::nameof::nameof<decltype(__VA_ARGS__)>(#__VA_ARGS__, false)
+
 // Used to obtain the full string name of a variable, member, function, enum, macros.
-#define NAMEOF_FULL(...) ::nameof::Nameof<decltype(__VA_ARGS__)>(#__VA_ARGS__, (sizeof(#__VA_ARGS__) / sizeof(char)) - 1, true)
+#define NAMEOF_FULL(...) ::nameof::nameof<decltype(__VA_ARGS__)>(#__VA_ARGS__, true)
+
 // Used to obtain the raw string name of a variable, member, function, enum, macros.
-#define NAMEOF_RAW(...) ::nameof::NameofRaw<decltype(__VA_ARGS__)>(#__VA_ARGS__, (sizeof(#__VA_ARGS__) / sizeof(char)) - 1)
+#define NAMEOF_RAW(...) ::nameof::nameof_raw<decltype(__VA_ARGS__)>(#__VA_ARGS__)
 
 // Used to obtain the simple (unqualified) string name of a enum variable.
-#define NAMEOF_ENUM(...) ::nameof::NameofEnum<decltype(__VA_ARGS__)>(__VA_ARGS__)
+#define NAMEOF_ENUM(...) ::nameof::nameof_enum<decltype(__VA_ARGS__)>(__VA_ARGS__)
 
 // Used to obtain the string name of a type.
-#define NAMEOF_TYPE(...) ::nameof::NameofType<decltype(__VA_ARGS__)>()
+#define NAMEOF_TYPE(...) ::nameof::nameof_type<decltype(__VA_ARGS__)>()
-#define NAMEOF_TYPE_T(...) ::nameof::NameofType<__VA_ARGS__>()
+#define NAMEOF_TYPE_T(...) ::nameof::nameof_type<__VA_ARGS__>()

test/CMakeLists.txt

@@ -68,20 +68,6 @@ function(make_target target std)
     endif()
 endfunction()
 
-if(HAS_CPP11_FLAG)
-    if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-        make_target(${CMAKE_PROJECT_NAME}-cpp11.t "")
-    else()
-        make_target(${CMAKE_PROJECT_NAME}-cpp11.t c++11)
-    endif()
-    add_test(NAME ${CMAKE_PROJECT_NAME}-cpp11.t COMMAND ${CMAKE_PROJECT_NAME}-cpp11.t)
-endif()
-
-if(HAS_CPP14_FLAG)
-    make_target(${CMAKE_PROJECT_NAME}-cpp14.t c++14)
-    add_test(NAME ${CMAKE_PROJECT_NAME}-cpp14.t COMMAND ${CMAKE_PROJECT_NAME}-cpp14.t)
-endif()
-
 if(HAS_CPP17_FLAG)
     set(std17 c++17)
     if(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")

test/test.cpp

@@ -1,7 +1,6 @@
-// nameof test
-//
 // Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-// Copyright (c) 2018 Daniil Goncharov <neargye@gmail.com>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018 - 2019 Daniil Goncharov <neargye@gmail.com>.
 //
 // Permission is hereby  granted, free of charge, to any  person obtaining a copy
 // of this software and associated  documentation files (the "Software"), to deal
@@ -38,12 +37,12 @@ struct SomeStruct {
 };
 
 void SomeMethod3() {
-  std::cout << NAMEOF(SomeMethod3) << " no called!" << std::endl;
+  throw std::runtime_error{"should not be called!"};
 }
 
 template <typename T, typename U>
-std::string SomeMethod4(U value) {
+std::string SomeMethod4(U) {
-  return NAMEOF(SomeMethod4<T, U>) + "<" + NAMEOF_TYPE_T(T) + ", " + NAMEOF_TYPE_T(U) + ">(" + NAMEOF_TYPE_T(U) + " " + NAMEOF(value) + ")";
+  throw std::runtime_error{"should not be called!"};
 }
 
 template <typename T>
@@ -87,71 +86,71 @@ TEST_CASE("constexpr") {
   SECTION("NAMEOF") {
     // variable
     constexpr auto cx1 = NAMEOF(struct_var);
-    static_assert(cx1 == "struct_var", "");
+    static_assert(cx1 == "struct_var");
     REQUIRE(cx1 == "struct_var");
     // member
     constexpr auto cx2 = NAMEOF((&struct_var)->somefield);
-    static_assert(cx2 == "somefield", "");
+    static_assert(cx2 == "somefield");
     REQUIRE(cx2 == "somefield");
     // function
     constexpr auto cx3 = NAMEOF(&SomeClass<int>::SomeMethod6<long int>);
-    static_assert(cx3 == "SomeMethod6", "");
+    static_assert(cx3 == "SomeMethod6");
     REQUIRE(cx3 == "SomeMethod6");
     // enum
     constexpr auto cx4 = NAMEOF(Color::RED);
-    static_assert(cx4 == "RED", "");
+    static_assert(cx4 == "RED");
     REQUIRE(cx4 == "RED");
   }
 
   SECTION("NAMEOF_FULL") {
     // variable
     constexpr auto cx1 = NAMEOF_FULL(struct_var);
-    static_assert(cx1 == "struct_var", "");
+    static_assert(cx1 == "struct_var");
     REQUIRE(cx1 == "struct_var");
     // member
     constexpr auto cx2 = NAMEOF_FULL((&struct_var)->somefield);
-    static_assert(cx2 == "somefield", "");
+    static_assert(cx2 == "somefield");
     REQUIRE(cx2 == "somefield");
     // function
     constexpr auto cx3 = NAMEOF_FULL(&SomeClass<int>::SomeMethod6<long int>);
-    static_assert(cx3 == "SomeMethod6<long int>", "");
+    static_assert(cx3 == "SomeMethod6<long int>");
     REQUIRE(cx3 == "SomeMethod6<long int>");
     // enum
     constexpr auto cx4 = NAMEOF_FULL(Color::RED);
-    static_assert(cx4 == "RED", "");
+    static_assert(cx4 == "RED");
     REQUIRE(cx4 == "RED");
   }
 
   SECTION("NAMEOF_RAW") {
     // variable
     constexpr auto cx1 = NAMEOF_RAW(struct_var);
-    static_assert(cx1 == "struct_var", "");
+    static_assert(cx1 == "struct_var");
     REQUIRE(cx1 == "struct_var");
     // member
     constexpr auto cx2 = NAMEOF_RAW((&struct_var)->somefield);
-    static_assert(cx2 == "(&struct_var)->somefield", "");
+    static_assert(cx2 == "(&struct_var)->somefield");
     REQUIRE(cx2 == "(&struct_var)->somefield");
     // function
     constexpr auto cx4 = NAMEOF_RAW(&SomeStruct::SomeMethod2);
-    static_assert(cx4 == "&SomeStruct::SomeMethod2", "");
+    static_assert(cx4 == "&SomeStruct::SomeMethod2");
     REQUIRE(cx4 == "&SomeStruct::SomeMethod2");
     // enum
     constexpr auto cx5 = NAMEOF_RAW(Color::RED);
-    static_assert(cx5 == "Color::RED", "");
+    static_assert(cx5 == "Color::RED");
     REQUIRE(cx5 == "Color::RED");
     // macros
     constexpr auto cx6 = NAMEOF_RAW(__cplusplus);
-    static_assert(cx6 == "__cplusplus", "");
+    static_assert(cx6 == "__cplusplus");
     REQUIRE(cx6 == "__cplusplus");
   }
 
-#if defined(NAMEOF_HAS_CONSTEXPR)
   SECTION("NAMEOF_ENUM") {
     constexpr auto cx = NAMEOF_ENUM(color);
 #if defined(__clang__) || defined(_MSC_VER)
-    static_assert(cx == "RED", "");
+    static_assert(cx == "RED");
     REQUIRE(cx == "RED");
 #elif defined(__GNUC__)
+    static_assert(cx == "(Color)-1");
     REQUIRE(cx == "(Color)-1");
 #endif
   }
@@ -159,12 +158,13 @@ TEST_CASE("constexpr") {
   SECTION("NAMEOF_TYPE") {
     constexpr auto cx = NAMEOF_TYPE(ptr_c);
 #if defined(__clang__)
-    static_assert(cx == "const volatile SomeClass<int> *", "");
+    static_assert(cx == "const volatile SomeClass<int> *");
     REQUIRE(cx == "const volatile SomeClass<int> *");
 #elif defined(__GNUC__)
+    static_assert(cx == "const volatile SomeClass<int>*");
     REQUIRE(cx == "const volatile SomeClass<int>*");
 #elif defined(_MSC_VER)
-    static_assert(cx == "SomeClass<int> const volatile *", "");
+    static_assert(cx == "SomeClass<int> const volatile *");
     REQUIRE(cx == "SomeClass<int> const volatile *");
 #endif
   }
@@ -172,16 +172,16 @@ TEST_CASE("constexpr") {
   SECTION("NAMEOF_TYPE_T") {
     constexpr auto cx = NAMEOF_TYPE_T(const SomeClass<int> volatile *);
 #if defined(__clang__)
-    static_assert(cx == "const volatile SomeClass<int> *", "");
+    static_assert(cx == "const volatile SomeClass<int> *");
     REQUIRE(cx == "const volatile SomeClass<int> *");
 #elif defined(__GNUC__)
+    static_assert(cx == "const volatile SomeClass<int>*");
     REQUIRE(cx == "const volatile SomeClass<int>*");
 #elif defined(_MSC_VER)
-    static_assert(cx == "SomeClass<int> const volatile *", "");
+    static_assert(cx == "SomeClass<int> const volatile *");
     REQUIRE(cx == "SomeClass<int> const volatile *");
 #endif
   }
-#endif
 }
 
 TEST_CASE("NAMEOF") {
@@ -461,5 +461,3 @@ TEST_CASE("Spaces and Tabs ignored") {
     REQUIRE(NAMEOF_TYPE_T(	decltype(struct_var)	) == "SomeStruct");
   }
 }
-
-TEST_CASE("cstring") {}