move type stuff from color, add test

dune/stuff/common/color.hh

@@ -78,29 +78,6 @@ std::string backcolor(int i)
   return "\033[38;5;" + Dune::Stuff::Common::String::convertTo(i) + "m";
 }
 
-// demangles typeid
-template <class T>
-std::string demangledTypeId(T& obj)
-{
-  int status;
-
-#ifdef __GNUC__
-  return abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status);
-
-#else // ifdef __GNUC__
-  return typeid(obj).name();
-
-#endif // ifdef __GNUC__
-} // demangledTypeId
-
-// create output for demangled typeid
-template <class T>
-void realTypeId(T& obj, std::string name = "", int maxlevel = 10000)
-{
-  std::cout << name << (name == "" ? "" : "'s type is ") << highlightTemplate(demangledTypeId(obj), maxlevel)
-            << std::endl;
-}
-
 // maybe you want to choose your own color
 int templateColorChooser(int i)
 {

dune/stuff/common/type_utils.hh

+#ifndef DUNE_STUFF_TYPENAMES_HH
+#define DUNE_STUFF_TYPENAMES_HH
+
+#include "color.hh"
+
+/** use this to define Typename specializations in the GLOBAL namespace ONLY **/
+#define STUFF_TYPENAME(NAME)                                                                                           \
+  namespace Dune {                                                                                                     \
+  namespace Stuff {                                                                                                    \
+  namespace Common {                                                                                                   \
+  template <>                                                                                                          \
+  struct Typename<NAME>                                                                                                \
+  {                                                                                                                    \
+    static const char* value()                                                                                         \
+    {                                                                                                                  \
+      return #NAME;                                                                                                    \
+    }                                                                                                                  \
+  };                                                                                                                   \
+  }                                                                                                                    \
+  }                                                                                                                    \
+  }
+
+namespace Dune {
+namespace Stuff {
+namespace Common {
+
+std::string demangleTypename(const std::string& mangled_name)
+{
+#ifdef __GNUC__
+  return abi::__cxa_demangle(mangled_name.c_str(), 0, 0, int());
+#else // ifdef __GNUC__
+  return mangled_name;
+#endif // ifdef __GNUC__
+}
+
+//! demangles typeid
+template <class T>
+std::string demangledTypeId(T& obj)
+{
+  return demangleTypename(typeid(obj).name());
+} // demangledTypeId
+
+//! create output for demangled typeid
+template <class T>
+void realTypeId(T& obj, std::string name = "", int maxlevel = 10000)
+{
+  std::cout << name << (name == "" ? "" : "'s type is ") << highlightTemplate(demangledTypeId(obj), maxlevel)
+            << std::endl;
+}
+
+//! an extensible mechanism to assign "cleartext" names to types
+template <typename T>
+struct Typename
+{
+  static std::string value()
+  {
+#if defined(__GNUC__) && defined(__GXX_RTTI)
+    return demangleTypename(typeid(T).name());
+#else
+    return "unknown";
+#endif
+  }
+};
+
+} // namespace Common
+} // namespace Stuff
+} // namespace Dune
+
+STUFF_TYPENAME(int)
+STUFF_TYPENAME(double)
+STUFF_TYPENAME(float)
+STUFF_TYPENAME(long)
+STUFF_TYPENAME(unsigned int)
+STUFF_TYPENAME(unsigned long)
+STUFF_TYPENAME(char)
+
+#endif // DUNE_STUFF_TYPENAMES_HH

dune/stuff/test/common_typenames.cc

@@ -4,13 +4,22 @@
 #include <config.h>
 #endif // ifdef HAVE_CMAKE_CONFIG
 
+#include <iostream>
+
 #include <dune/common/mpihelper.hh>
+#include <dune/stuff/common/type_utils.hh>
+
+STUFF_TYPENAME(Dune::MPIHelper)
 
 int main(int argc, char** argv)
 {
+  using namespace Dune::Stuff::Common;
   try {
     // mpi
     Dune::MPIHelper::instance(argc, argv);
+    std::cout << "builtin typename:\nunsigned long  -> " << Typename<unsigned long>::value()
+              << "\nunknown: Dune::Exception  -> " << Typename<Dune::Exception>::value()
+              << "\nextended: Dune::MPIHelper -> " << Typename<Dune::MPIHelper>::value() << std::endl;
 
   } catch (Dune::Exception& e) {
     std::cout << e.what() << std::endl;