refactor GetNamespace to replace string_view with string and use typeid for namespace extraction

Author: allnes

modules/core/performance/tests/perf_tests.cpp

@@ -263,7 +263,7 @@ using TestTypes = ::testing::Types<my::nested::Type, my::Another, int>;
 TYPED_TEST_SUITE(GetNamespaceTest, TestTypes);
 
 TYPED_TEST(GetNamespaceTest, ExtractsNamespaceCorrectly) {
-  constexpr std::string_view kNs = ppc::util::GetNamespace<TypeParam>();
+  std::string kNs = ppc::util::GetNamespace<TypeParam>();
 
   if constexpr (std::is_same_v<TypeParam, my::nested::Type>) {
     EXPECT_EQ(kNs, "my::nested");

modules/core/util/include/util.hpp

@@ -5,7 +5,10 @@
 #include <memory>
 #include <source_location>
 #include <string>
-#include <string_view>
+#include <typeinfo>
+#ifdef __GNUG__
+#include <cxxabi.h>
+#endif
 
 #include "nlohmann/json_fwd.hpp"
 
@@ -49,24 +52,16 @@ std::string GetAbsoluteTaskPath(const std::string& id_path, const std::string& r
 int GetNumThreads();
 
 template <typename T>
-constexpr std::string_view GetNamespace() {
-#ifdef _MSC_VER
-  constexpr std::string_view kFunc{__FUNCSIG__};
-  constexpr std::string_view kKey = "GetNamespace<";
-#else
-  constexpr std::string_view kFunc{__PRETTY_FUNCTION__};
-  constexpr std::string_view kKey = "T = ";
+std::string GetNamespace() {
+  std::string name = typeid(T).name();
+#ifdef __GNUG__
+  int status = 0;
+  std::unique_ptr<char, void (*)(void*)> demangled{abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status),
+                                                   std::free};
+  name = (status == 0) ? demangled.get() : name;
 #endif
-
-  auto start = kFunc.find(kKey);
-  start = (start == std::string_view::npos) ? kFunc.size() : start + kKey.size();
-
-  for (auto p : {"class ", "struct ", "enum ", "union "})
-    if (kFunc.substr(start).starts_with(p)) start += std::string_view{p}.size();
-
-  auto ns_type = kFunc.substr(start, kFunc.find(']', start) - start);
-  auto pos = ns_type.rfind("::");
-  return (pos != std::string_view::npos) ? ns_type.substr(0, pos) : std::string_view{};
+  auto pos = name.rfind("::");
+  return (pos != std::string::npos) ? name.substr(0, pos) : std::string{};
 }
 
 inline std::shared_ptr<nlohmann::json> InitJSONPtr() { return std::make_shared<nlohmann::json>(); }

modules/core/util/tests/util.cpp

@@ -12,7 +12,7 @@ struct Type {};
 }  // namespace my::nested
 
 TEST(util_tests, extracts_correct_namespace) {
-  constexpr std::string_view kNs = ppc::util::GetNamespace<my::nested::Type>();
+  std::string kNs = ppc::util::GetNamespace<my::nested::Type>();
   EXPECT_EQ(kNs, "my::nested");
 }
 
@@ -29,17 +29,17 @@ struct TypeInNamespace {};
 struct PlainType {};
 
 TEST(GetNamespaceTest, ReturnsExpectedNamespace) {
-  constexpr auto kNs = ppc::util::GetNamespace<test_ns::TypeInNamespace>();
+  std::string kNs = ppc::util::GetNamespace<test_ns::TypeInNamespace>();
   EXPECT_EQ(kNs, "test_ns");
 }
 
 TEST(GetNamespaceTest, ReturnsEmptyIfNoNamespace_PrimitiveType) {
-  constexpr auto kNs = ppc::util::GetNamespace<int>();
+  std::string kNs = ppc::util::GetNamespace<int>();
   EXPECT_EQ(kNs, "");
 }
 
 TEST(GetNamespaceTest, ReturnsEmptyIfNoNamespace_PlainStruct) {
-  constexpr auto kNs = ppc::util::GetNamespace<PlainType>();
+  std::string kNs = ppc::util::GetNamespace<PlainType>();
   EXPECT_EQ(kNs, "");
 }
 
@@ -48,22 +48,22 @@ struct Nested {};
 }  // namespace test_ns
 
 TEST(GetNamespaceTest, ReturnsNamespaceCorrectly) {
-  constexpr auto kNs = ppc::util::GetNamespace<test_ns::Nested>();
+  std::string kNs = ppc::util::GetNamespace<test_ns::Nested>();
   EXPECT_EQ(kNs, "test_ns");
 }
 
 struct NoNamespaceType {};
 
 TEST(GetNamespaceTest, NoNamespaceInType) {
-  constexpr auto kNs = ppc::util::GetNamespace<NoNamespaceType>();
+  std::string kNs = ppc::util::GetNamespace<NoNamespaceType>();
   EXPECT_EQ(kNs, "");
 }
 
 template <typename T>
 struct NotATemplate {};
 
 TEST(GetNamespaceTest, NoKeyInPrettyFunction) {
-  constexpr auto kNs = ppc::util::GetNamespace<NotATemplate<void>>();
+  std::string kNs = ppc::util::GetNamespace<NotATemplate<void>>();
   EXPECT_EQ(kNs, "");
 }
 
@@ -72,6 +72,6 @@ struct VeryLongTypeNameWithOnlyLettersAndUnderscores {};
 }  // namespace crazy
 
 TEST(GetNamespaceTest, NoTerminatorCharactersInPrettyFunction) {
-  constexpr auto kNs = ppc::util::GetNamespace<crazy::VeryLongTypeNameWithOnlyLettersAndUnderscores>();
+  std::string kNs = ppc::util::GetNamespace<crazy::VeryLongTypeNameWithOnlyLettersAndUnderscores>();
   EXPECT_EQ(kNs, "crazy");
 }