chore: use core::typeinfo

Author: vinniefalco

include/boost/rts/detail/type_info.hpp

@@ -13,17 +13,88 @@
 #include <boost/rts/detail/config.hpp>
 #include <boost/rts/detail/call_traits.hpp>
 #include <boost/rts/detail/except.hpp>
-#include <boost/rts/detail/type_info.hpp>
 #include <boost/rts/detail/type_traits.hpp>
+#include <boost/core/typeinfo.hpp>
 #include <boost/core/detail/static_assert.hpp>
+#include <cstring>
 #include <memory>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
 
+#if ! defined( BOOST_NO_TYPEID )
+#include <typeindex>
+#endif
+
 namespace boost {
 namespace rts {
 
+namespace detail {
+
+#if defined( BOOST_NO_TYPEID )
+
+struct typeindex
+{
+    typeindex(
+        core::typeinfo const& ti) noexcept
+        : n_(std::strlen(ti.name()))
+        , ti_(&ti)
+    { 
+    }
+
+    std::size_t hash_code() const noexcept
+    {
+        constexpr std::size_t offset_basis =
+            (sizeof(std::size_t) == 8)
+                ? 1469598103934665603ull
+                : 2166136261u;
+        constexpr std::size_t prime =
+            (sizeof(std::size_t) == 8)
+                ? 1099511628211ull
+                : 16777619u;
+        auto const s = ti_->name();
+        std::size_t h = offset_basis;
+        for(std::size_t i = 0; i < n_; ++i)
+            h = (h ^ static_cast<unsigned char>(s[i])) * prime;
+        return h;
+    }
+
+    bool operator==(typeindex const& other) const noexcept
+    {
+        return n_ == other.n_ && *ti_ == *other.ti_;
+    }
+
+private:
+    std::size_t n_;
+    core::typeinfo const* ti_;
+};
+
+} // detail
+} // rts
+} // boost
+namespace std {
+template<>
+struct hash< boost::rts::detail::typeindex >
+{
+    std::size_t operator()(
+        boost::rts::detail::typeindex const& t) const noexcept
+    {
+        return t.hash_code();
+    }
+};
+} // std
+namespace boost {
+namespace rts {
+namespace detail {
+
+#else
+
+using typeindex = std::type_index;
+
+#endif
+
+} // detail
+
 /** A container of type-erased objects
 
     Objects are stored and retrieved by their type.
@@ -135,8 +206,7 @@ class polystore
     template<class T>
     T* find() const noexcept
     {
-        return static_cast<T*>(find(
-            detail::get_type_info<T>()));
+        return static_cast<T*>(find(BOOST_CORE_TYPEID(T)));
     }
 
     /** Return a reference to the object associated with type T
@@ -457,8 +527,11 @@ class polystore
 
     struct key
     {
-        detail::type_info const* ti;
+        detail::typeindex ti;
         void* p;
+
+        key(detail::typeindex const& ti_,
+            void* p_) noexcept : ti(ti_) , p(p_) {}
     };
 
     template<class T, class... Key>
@@ -471,7 +544,7 @@ class polystore
         key kn[1];
 
         explicit keyset(T& t) noexcept
-            : kn{{ &detail::get_type_info<T>(), &t }}
+            : kn{{ detail::typeindex(BOOST_CORE_TYPEID(T)), &t }}
         {
         }
     };
@@ -484,9 +557,9 @@ class polystore
 
         explicit keyset(T& t) noexcept
             : kn{
-                {   &detail::get_type_info<T>(),
+                {   detail::typeindex(BOOST_CORE_TYPEID(T)),
                     std::addressof(t) },
-                {   &detail::get_type_info<Keys>(),
+                {   detail::typeindex(BOOST_CORE_TYPEID(Keys)),
                     &static_cast<Keys&>(t) }...,
             }
         {
@@ -509,34 +582,13 @@ class polystore
     void destroy() noexcept;
     BOOST_RTS_DECL any& get(std::size_t i);
     BOOST_RTS_DECL void* find(
-        detail::type_info const& ti) const noexcept;
+        core::typeinfo const& ti) const noexcept;
     BOOST_RTS_DECL void* insert_impl(any_ptr,
         key const* = nullptr, std::size_t = 0);
 
-    struct hash
-    {
-        std::size_t operator()(
-            detail::type_info const* p) const noexcept
-        {
-            return p->hash_code();
-        }
-    };
-
-    struct eq
-    {
-        bool operator()(
-            detail::type_info const* p0,
-            detail::type_info const* p1) const noexcept
-        {
-            return *p0 == *p1;
-        }
-    };
-
     std::vector<any_ptr> v_;
     std::unordered_map<
-        detail::type_info const*,
-            void*, hash, eq> m_;
-
+        detail::typeindex, void*> m_;
 };
 
 //------------------------------------------------

include/boost/rts/polystore.hpp

@@ -82,9 +82,9 @@ get(std::size_t i) -> any&
 void*
 polystore::
 find(
-    detail::type_info const& ti) const noexcept
+    core::typeinfo const& ti) const noexcept
 {
-    auto const it = m_.find(&ti);
+    auto const it = m_.find(ti);
     if(it == m_.end())
         return nullptr;
     return it->second;