Use function address as TypeIndex (#6)

* use function address as TypeID

* use std::size_t

* use struct member address instead

* add test for anonymous types

* use decltype to get index type

* use old solution for gcc

* switch to minor release

* change compiler test to macro

* update how it works section

* update version in readme

* move test to TypeIndex

* use static assert

* allow switching the member pointer macro

Author: TheLartians

CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 
 # Note: update this to your new project's name and version
 project(StaticTypeInfo 
-  VERSION 1.2
+  VERSION 1.3
   LANGUAGES CXX
 )
 

README.md

@@ -36,32 +36,24 @@ void example() {
 }
 ```
 
-## How it works
-
-The type name is extracted from the macro `__PRETTY_FUNCTION__` (clang/gcc) or `__FUNCSIG__` (on MSVC) inside a probe function and converted to a `string_view` using the `constexpr` constructor.
-The type index is a 64 bit fnv1a hash of the type name.
-
-## Hash collisions
-
-hash collisions are theoretically possible but very unlikely, assuming that fnv1a is a sufficiently strong hash function. If the generated hashes are more or less uniformly distributed the [probability of a collision](https://en.wikipedia.org/wiki/Birthday_problem) should be approximately `T^2 / (2^65)` for any reasonable number of types `T`.
-So for a program with 1000 unique types, the probability of a hash collision in that program is on the order of `10^(-14)`, which is incredibly unlikely.
-For most real-life purpose we can therefore assume all hashes to be unique.
-
-If you are paranoid or working on a security relevant project, you could bring that probability down to `0` with a simple test case checking the uniqueness of all used type indices within the project.
-
 ## Compatibility
 
 The library has been tested with AppleClang 11, Visual Studio 16 2019, and gcc-9.
 Note that type names and indices are not compatible between compilers.
 
+## How it works
+
+ The type name is extracted from the macro `__PRETTY_FUNCTION__` (clang/gcc) or `__FUNCSIG__` (on MSVC) inside a probe function and converted to a `string_view` using the `constexpr` constructor.
+ The type index is determined from the pointer to a static member of a templated string (clang / msvc) or from a 64 bit fnv1a hash of the type name (gcc and others).
+
 ## How to integrate
 
 Use [CPM.cmake](https://github.com/TheLartians/CPM.cmake) to easily add the headers to your CMake project.
 
 ```cmake
 CPMAddPackage(
   NAME StaticTypeInfo
-  VERSION 1.1
+  VERSION 1.3
   GIT_REPOSITORY https://github.com/TheLartians/StaticTypeInfo
 )
 

include/static_type_info/type_id.h

@@ -22,6 +22,7 @@ namespace static_type_info {
 
 namespace std {
   template <> struct hash<static_type_info::TypeID> {
-    size_t operator()(const static_type_info::TypeID &id) const { return id.index; }
+    hash<static_type_info::TypeIndex> hasher;
+    size_t operator()(const static_type_info::TypeID &id) const { return hasher(id.index); }
   };
 }  // namespace std

include/static_type_info/type_index.h

@@ -1,7 +1,33 @@
 #pragma once
 
-#include <static_type_info/hash.h>
-#include <static_type_info/type_name.h>
+#ifndef STATIC_TYPE_INFO_USE_MEMBER_POINTER
+// enable the new implementation using member pointers on tested compilers
+// gcc currently fails as member pointers are not considered constexpr
+#  if defined(__clang__) || defined(_MSC_VER)
+#    define STATIC_TYPE_INFO_USE_MEMBER_POINTER true
+#  else
+#    define STATIC_TYPE_INFO_USE_MEMBER_POINTER false
+#  endif
+#endif
+
+#if STATIC_TYPE_INFO_USE_MEMBER_POINTER
+
+namespace static_type_info {
+
+  namespace detail {
+    template <typename T> struct IDGenerator { static const void* const id; };
+    template <typename T> const void* const IDGenerator<T>::id = nullptr;
+  }  // namespace detail
+
+  using TypeIndex = decltype(&detail::IDGenerator<void>::id);
+  template <class T> constexpr TypeIndex getTypeIndex() { return &detail::IDGenerator<T>::id; }
+
+}  // namespace static_type_info
+
+#else
+
+#  include <static_type_info/hash.h>
+#  include <static_type_info/type_name.h>
 
 namespace static_type_info {
 
@@ -12,3 +38,5 @@ namespace static_type_info {
   }
 
 }  // namespace static_type_info
+
+#endif

test/CMakeLists.txt

@@ -31,7 +31,7 @@ endif()
 CPMAddPackage(
   NAME Format.cmake
   GITHUB_REPOSITORY TheLartians/Format.cmake
-  VERSION 1.0
+  VERSION 1.4
 )
 
 # ---- Create binary ----

test/source/type_index.cpp

@@ -1,6 +1,7 @@
 #include <doctest/doctest.h>
 #include <static_type_info/type_index.h>
 
+#include <cstddef>
 #include <type_traits>
 
 namespace ns {
@@ -14,14 +15,16 @@ template <class A, class B> void checkType() {
   constexpr auto ia = getTypeIndex<A>();
   constexpr auto ib = getTypeIndex<B>();
   static_assert(ia != ib || std::is_same<A, B>::value);
-  if (std::is_same<A, B>::value) {
+  if constexpr (std::is_same<A, B>::value) {
     CHECK(ia == ib);
+    static_assert(ia == ib);
   } else {
     CHECK(ia != ib);
+    static_assert(ia != ib);
   }
 }
 
-TEST_CASE_TEMPLATE("TypeIndex", T, char, int, unsigned, float, double, long, long long, size_t,
+TEST_CASE_TEMPLATE("TypeIndex", T, char, int, unsigned, float, double, long, long long, std::size_t,
                    ns::A, ns::B, ns::C<ns::A>, ns::C<ns::B>) {
   checkType<char, T>();
   checkType<int, T>();
@@ -36,3 +39,22 @@ TEST_CASE_TEMPLATE("TypeIndex", T, char, int, unsigned, float, double, long, lon
   checkType<ns::C<ns::A>, T>();
   checkType<ns::C<ns::B>, T>();
 }
+
+#if STATIC_TYPE_INFO_USE_MEMBER_POINTER
+// Anonymous functions are incompatible with the name based implementation
+
+template <class T> constexpr auto getAnonymousTypeIndex() {
+  using namespace static_type_info;
+  struct X {};
+  return getTypeIndex<X>();
+}
+
+TEST_CASE("Anonymous types") {
+  static_assert(getAnonymousTypeIndex<int>() != getAnonymousTypeIndex<unsigned>());
+  static_assert(getAnonymousTypeIndex<int>() != getAnonymousTypeIndex<float>());
+  static_assert(getAnonymousTypeIndex<int>() != getAnonymousTypeIndex<double>());
+}
+
+#elif defined(__clang__) || defined(_MSC_VER)
+#  error STATIC_TYPE_INFO_USE_MEMBER_POINTER not enabled
+#endif