rice 4.7.1 → 4.9.0

data/rice/detail/Type.ipp

@@ -71,37 +71,20 @@ namespace Rice::detail
   {
   };
 
-  // ---------- TypeMapper ------------
-  template<typename T>
-  inline std::string TypeMapper<T>::demangle(char const* mangled_name)
+  // ---------- TypeIndexParser ------------
+  inline TypeIndexParser::TypeIndexParser(const std::type_index& typeIndex, bool isFundamental) :
+    typeIndex_(typeIndex), isFundamental_(isFundamental)
   {
-#ifdef __GNUC__
-    struct Helper
-    {
-      Helper(
-        char const* mangled_name)
-        : name_(0)
-      {
-        int status = 0;
-        name_ = abi::__cxa_demangle(mangled_name, 0, 0, &status);
-      }
-
-      ~Helper()
-      {
-        std::free(name_);
-      }
-
-      char* name_;
-
-    private:
-      Helper(Helper const&);
-      void operator=(Helper const&);
-    };
+  }
 
-    Helper helper(mangled_name);
-    if (helper.name_)
+  inline std::string TypeIndexParser::demangle(char const* mangled_name)
+  {
+#ifdef __GNUC__
+    int status = 0;
+    char* name = abi::__cxa_demangle(mangled_name, 0, 0, &status);
+    if (name)
     {
-      return helper.name_;
+      return name;
     }
     else
     {
@@ -112,17 +95,9 @@ namespace Rice::detail
 #endif
   }
 
-  template<typename T>
-  inline std::string TypeMapper<T>::name()
+  inline std::string TypeIndexParser::name()
   {
-    const std::type_index& typeIndex = typeid(T);
-    return demangle(typeIndex.name());
-  }
-
-  template<typename T>
-  inline std::string TypeMapper<T>::name(const std::type_index& typeIndex)
-  {
-    return demangle(typeIndex.name());
+    return this->demangle(this->typeIndex_.name());
   }
 
   // Find text inside of < > taking into account nested groups.
@@ -130,8 +105,7 @@ namespace Rice::detail
   // Example:
   //  
   //   std::vector<std::vector<int>, std::allocator<std::vector, std::allocator<int>>>
-  template<typename T>
-  inline std::string TypeMapper<T>::findGroup(std::string& string, size_t offset)
+  inline std::string TypeIndexParser::findGroup(std::string& string, size_t offset)
   {
     int depth = 0;
 
@@ -164,8 +138,7 @@ namespace Rice::detail
     throw std::runtime_error("Unbalanced Group");
   }
 
-  template<typename T>
-  inline void TypeMapper<T>::replaceAll(std::string& string, std::regex regex, std::string replacement)
+  inline void TypeIndexParser::replaceAll(std::string& string, std::regex regex, std::string replacement)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -174,8 +147,7 @@ namespace Rice::detail
     }
   }
 
-  template<typename T>
-  inline void TypeMapper<T>::removeGroup(std::string& string, std::regex regex)
+  inline void TypeIndexParser::removeGroup(std::string& string, std::regex regex)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -186,8 +158,7 @@ namespace Rice::detail
     }
   }
 
-  template<typename T>
-  inline void TypeMapper<T>::replaceGroup(std::string& string, std::regex regex, std::string replacement)
+  inline void TypeIndexParser::replaceGroup(std::string& string, std::regex regex, std::string replacement)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -198,8 +169,7 @@ namespace Rice::detail
     }
   }
 
-  template<typename T>
-  inline std::string TypeMapper<T>::simplifiedName()
+  inline std::string TypeIndexParser::simplifiedName()
   {
     std::string base = this->name();
 
@@ -239,6 +209,10 @@ namespace Rice::detail
     std::regex equalRegex(R"(,\s*std::equal_to)");
     removeGroup(base, equalRegex);
 
+    // Remove default_delete (std::unique_ptr)
+    std::regex defaultDeleteRegex(R"(,\s*std::default_delete)");
+    removeGroup(base, defaultDeleteRegex);
+
     // Remove spaces before pointers
     std::regex ptrRegex = std::regex(R"(\s+\*)");
     base = std::regex_replace(base, ptrRegex, "*");
@@ -271,42 +245,9 @@ namespace Rice::detail
     return base;
   }
 
-  template<typename T>
-  inline void TypeMapper<T>::capitalizeHelper(std::string& content, std::regex& regex)
+  inline std::string TypeIndexParser::rubyName(std::string rubyTypeName)
   {
-    std::smatch match;
-    while (std::regex_search(content, match, regex))
-    {
-      std::string replacement = match[1];
-      std::transform(replacement.begin(), replacement.end(), replacement.begin(), ::toupper);
-      content.replace(match.position(), match.length(), replacement);
-    }
-  }
-
-  template<typename T>
-  inline std::string TypeMapper<T>::rubyTypeName()
-  {
-    using Intrinsic_T = detail::intrinsic_type<T>;
-
-    if constexpr (std::is_fundamental_v<T>)
-    {
-      return RubyType<Intrinsic_T>::name;
-    }
-    else if constexpr (std::is_same_v<std::remove_cv_t<T>, char*>)
-    {
-      return "String";
-    }
-    else
-    {
-      detail::TypeMapper<Intrinsic_T> typeIntrinsicMapper;
-      return typeIntrinsicMapper.simplifiedName();
-    }
-  }
-
-  template<typename T>
-  inline std::string TypeMapper<T>::rubyName()
-  {
-    std::string base = this->rubyTypeName();
+    std::string base = rubyTypeName;
 
     // Remove std:: these could be embedded in template types
     auto stdRegex = std::regex("std::");
@@ -318,50 +259,93 @@ namespace Rice::detail
     base = std::regex_replace(base, leadingNamespacesRegex, "");
 
     // Capitalize first letter
-    base[0] = std::toupper(base[0]);
+    base[0] = (char)std::toupper(base[0]);
 
     // Replace :: with unicode U+u02F8 (Modified Letter raised colon)
     auto colonRegex = std::regex(R"(:)");
-    replaceAll(base, colonRegex, "\uA789");
+    this->replaceAll(base, colonRegex, "\uA789");
 
     // Replace _ and capitalize the next letter
     std::regex underscoreRegex(R"(_(\w))");
-    capitalizeHelper(base, underscoreRegex);
+    this->capitalizeHelper(base, underscoreRegex);
 
-    if constexpr (std::is_fundamental_v<intrinsic_type<T>>)
+    if (this->isFundamental_)
     {
       // Replace space and capitalize the next letter
       std::regex spaceRegex(R"(\s+(\w))");
-      capitalizeHelper(base, spaceRegex);
+      this->capitalizeHelper(base, spaceRegex);
     }
     else
     {
       // Replace spaces with unicode U+u00A0 (Non breaking Space)
       std::regex spaceRegex = std::regex(R"(\s+)");
-      replaceAll(base, spaceRegex, "\u00A0");
+      this->replaceAll(base, spaceRegex, "\u00A0");
     }
 
     // Replace < with unicode U+227A (Precedes)
     auto lessThanRegex = std::regex("<");
     //replaceAll(base, lessThanRegex, "≺");
-    replaceAll(base, lessThanRegex, "\u227A");
+    this->replaceAll(base, lessThanRegex, "\u227A");
 
     // Replace > with unicode U+227B (Succeeds)
     auto greaterThanRegex = std::regex(">");
     //replaceAll(base, greaterThanRegex, "≻");
-    replaceAll(base, greaterThanRegex, "\u227B");
+    this->replaceAll(base, greaterThanRegex, "\u227B");
 
     // Replace , with Unicode Character (U+066C) - Arabic Thousands Separator
     auto commaRegex = std::regex(R"(,\s*)");
-    replaceAll(base, commaRegex, "\u201A");
+    this->replaceAll(base, commaRegex, "\u201A");
 
     // Replace * with Unicode Character (U+2217) -	Asterisk Operator
     auto asteriskRegex = std::regex(R"(\*)");
-    replaceAll(base, asteriskRegex, "\u2217");
+    this->replaceAll(base, asteriskRegex, "\u2217");
 
     return base;
   }
 
+  inline void TypeIndexParser::capitalizeHelper(std::string& content, std::regex& regex)
+  {
+    std::smatch match;
+    while (std::regex_search(content, match, regex))
+    {
+      std::string replacement = match[1];
+      std::transform(replacement.begin(), replacement.end(), replacement.begin(), 
+        [](unsigned char c) -> char
+        {
+          return static_cast<char>(std::toupper(c));
+        });
+      content.replace(match.position(), match.length(), replacement);
+    }
+  }
+
+  // ---------- TypeMapper ------------
+  template<typename T>
+  inline std::string TypeMapper<T>::rubyTypeName()
+  {
+    using Intrinsic_T = detail::intrinsic_type<T>;
+
+    if constexpr (std::is_fundamental_v<T>)
+    {
+      return RubyType<Intrinsic_T>::name;
+    }
+    else if constexpr (std::is_same_v<std::remove_cv_t<T>, char*>)
+    {
+      return "String";
+    }
+    else
+    {
+      detail::TypeIndexParser typeIndexParser(typeid(Intrinsic_T), std::is_fundamental_v<detail::intrinsic_type<Intrinsic_T>>);
+      return typeIndexParser.simplifiedName();
+    }
+  }
+
+  template<typename T>
+  inline std::string TypeMapper<T>::rubyName()
+  {
+    std::string base = this->rubyTypeName();
+    return this->typeIndexParser_.rubyName(base);
+  }
+
   template<typename T>
   inline VALUE TypeMapper<T>::rubyKlass()
   {

data/rice/detail/TypeRegistry.ipp

@@ -97,8 +97,9 @@ namespace Rice::detail
       return result.value();
     }
 
-    detail::TypeMapper<T> typeMapper;
-    raiseUnverifiedType(typeMapper.name());
+    detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    raiseUnverifiedType(typeIndexParser.name());
+
     // Make the compiler happy
     return std::pair<VALUE, rb_data_type_t*>(Qnil, nullptr);
   }
@@ -131,8 +132,8 @@ namespace Rice::detail
 
     for (const std::type_index& typeIndex : this->unverified_)
     {
-      detail::TypeMapper<int> typeMapper;
-      stream << "  " << typeMapper.name(typeIndex) << "\n";
+      detail::TypeIndexParser typeIndexParser(typeIndex);
+      stream << "  " << typeIndexParser.name() << "\n";
     }
 
     throw std::invalid_argument(stream.str());

data/rice/detail/Wrapper.hpp

@@ -6,9 +6,9 @@ namespace Rice::detail
   class WrapperBase
   {
   public:
-    WrapperBase() = default;
+    WrapperBase(rb_data_type_t* rb_data_type);
     virtual ~WrapperBase() = default;
-    virtual void* get() = 0;
+    virtual void* get(rb_data_type_t* requestedType) = 0;
     bool isConst();
 
     void ruby_mark();
@@ -16,6 +16,7 @@ namespace Rice::detail
     void setOwner(bool value);
 
   protected:
+    rb_data_type_t* rb_data_type_;
     bool isOwner_ = false;
     bool isConst_ = false;
 
@@ -30,10 +31,10 @@ namespace Rice::detail
   class Wrapper : public WrapperBase
   {
   public:
-    Wrapper(T& data);
-    Wrapper(T&& data);
+    Wrapper(rb_data_type_t* rb_data_type, T& data);
+    Wrapper(rb_data_type_t* rb_data_type, T&& data);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T data_;
@@ -43,9 +44,9 @@ namespace Rice::detail
   class Wrapper<T&> : public WrapperBase
   {
   public:
-    Wrapper(T& data);
+    Wrapper(rb_data_type_t* rb_data_type, T& data);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T& data_;
@@ -55,9 +56,9 @@ namespace Rice::detail
   class Wrapper<T*> : public WrapperBase
   {
   public:
-    Wrapper(T* data, bool isOwner);
+    Wrapper(rb_data_type_t* rb_data_type, T* data, bool isOwner);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T* data_ = nullptr;
@@ -67,9 +68,9 @@ namespace Rice::detail
   class Wrapper<T**> : public WrapperBase
   {
   public:
-    Wrapper(T** data, bool isOwner);
+    Wrapper(rb_data_type_t* rb_data_type, T** data, bool isOwner);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T** data_ = nullptr;
@@ -77,7 +78,7 @@ namespace Rice::detail
 
   // ---- Helper Functions ---------
   template <typename T>
-  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner);
+  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data);
 
   template <typename T>
   VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner);

data/rice/detail/Wrapper.ipp

@@ -2,6 +2,10 @@
 
 namespace Rice::detail
 {
+  inline WrapperBase::WrapperBase(rb_data_type_t* rb_data_type) : rb_data_type_(rb_data_type)
+  {
+  }
+
   inline bool WrapperBase::isConst()
   {
     return this->isConst_;
@@ -27,30 +31,40 @@ namespace Rice::detail
 
   // ----  Wrapper -----
   template <typename T>
-  inline Wrapper<T>::Wrapper(T& data): data_(data)
+  inline Wrapper<T>::Wrapper(rb_data_type_t* rb_data_type, T& data) : WrapperBase(rb_data_type), data_(data)
   {
+    this->isConst_ = std::is_const_v<std::remove_reference_t<T>>;
   }
 
   template <typename T>
-  inline Wrapper<T>::Wrapper(T&& data) : data_(std::move(data))
+  inline Wrapper<T>::Wrapper(rb_data_type_t* rb_data_type, T&& data) : WrapperBase(rb_data_type), data_(std::move(data))
   {
   }
 
   template <typename T>
   inline Wrapper<T>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template <typename T>
-  inline void* Wrapper<T>::Wrapper::get()
+  inline void* Wrapper<T>::get(rb_data_type_t* requestedType)
   {
-    return (void*)&this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)&this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper& -----
   template <typename T>
-  inline Wrapper<T&>::Wrapper(T& data): data_(data)
+  inline Wrapper<T&>::Wrapper(rb_data_type_t* rb_data_type, T& data) : WrapperBase(rb_data_type), data_(data)
   {
     this->isConst_ = std::is_const_v<std::remove_reference_t<T>>;
   }
@@ -58,18 +72,27 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T&>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template <typename T>
-  inline void* Wrapper<T&>::get()
+  inline void* Wrapper<T&>::get(rb_data_type_t* requestedType)
   {
-    return (void*)&this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)&this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper* -----
   template <typename T>
-  inline Wrapper<T*>::Wrapper(T* data, bool isOwner) : data_(data)
+  inline Wrapper<T*>::Wrapper(rb_data_type_t* rb_data_type, T* data, bool isOwner) : WrapperBase(rb_data_type), data_(data)
   {
     this->isOwner_ = isOwner;
     this->isConst_ = std::is_const_v<std::remove_pointer_t<T>>;
@@ -78,7 +101,8 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T*>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+
     if constexpr (std::is_destructible_v<T>)
     {
       if (this->isOwner_)
@@ -89,14 +113,23 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void* Wrapper<T*>::get()
+  inline void* Wrapper<T*>::get(rb_data_type_t* requestedType)
   {
-    return (void*)this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper** -----
   template <typename T>
-  inline Wrapper<T**>::Wrapper(T** data, bool isOwner) : data_(data)
+  inline Wrapper<T**>::Wrapper(rb_data_type_t* rb_data_type, T** data, bool isOwner) : WrapperBase(rb_data_type), data_(data)
   {
     this->isOwner_ = isOwner;
     this->isConst_ = std::is_const_v<std::remove_pointer_t<std::remove_pointer_t<T>>>;
@@ -105,7 +138,8 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T**>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+
     if constexpr (std::is_destructible_v<T>)
     {
       if (this->isOwner_)
@@ -116,9 +150,18 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void* Wrapper<T**>::get()
+  inline void* Wrapper<T**>::get(rb_data_type_t* requestedType)
   {
-    return (void*)this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ---- Helper Functions -------
@@ -135,21 +178,21 @@ namespace Rice::detail
     // If Ruby is not the owner then wrap the reference
     if (!isOwner)
     {
-      wrapper = new Wrapper<T&>(data);
+      wrapper = new Wrapper<T&>(rb_data_type, data);
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
-    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> return true. Sigh.
+    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
     else if constexpr (detail::is_std_vector_v<T>)
     {
       if constexpr (std::is_copy_constructible_v<typename T::value_type>)
       {
-        wrapper = new Wrapper<T>(data);
+        wrapper = new Wrapper<T>(rb_data_type, data);
         result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
       }
       else
       {
-        wrapper = new Wrapper<T>(std::move(data));
+        wrapper = new Wrapper<T>(rb_data_type, std::move(data));
         result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
       }
     }
@@ -157,26 +200,26 @@ namespace Rice::detail
     // Ruby is the owner so copy data
     else if constexpr (std::is_copy_constructible_v<T>)
     {
-      wrapper = new Wrapper<T>(data);
+      wrapper = new Wrapper<T>(rb_data_type, data);
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
     // Ruby is the owner so move data
     else if constexpr (std::is_move_constructible_v<T>)
     {
-      wrapper = new Wrapper<T>(std::move(data));
+      wrapper = new Wrapper<T>(rb_data_type, std::move(data));
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
     else
     {
-      detail::TypeMapper<T> typeMapper;
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
       std::string message = "Rice was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: " +
-        typeMapper.name();
+        typeIndexParser.name();
       throw std::runtime_error(message);
     }
 
-    Registries::instance.instances.add(wrapper->get(), result);
+    Registries::instance.instances.add(wrapper->get(rb_data_type), result);
 
     return result;
   };
@@ -189,37 +232,40 @@ namespace Rice::detail
     if (result != Qnil)
       return result;
 
-    WrapperBase* wrapper = new Wrapper<T*>(data, isOwner);
+    WrapperBase* wrapper = new Wrapper<T*>(rb_data_type, data, isOwner);
     result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
 
-    Registries::instance.instances.add(wrapper->get(), result);
+    Registries::instance.instances.add(wrapper->get(rb_data_type), result);
     return result;
   };
 
   template <typename T>
   inline T* unwrap(VALUE value, rb_data_type_t* rb_data_type, bool takeOwnership)
   {
-    if (rb_type(value) != RUBY_T_DATA)
+    if (!RTYPEDDATA_P(value))
     {
-      std::string message = "The provided Ruby object does not wrap a C++ object";
+      std::string message = "The Ruby object does not wrap a C++ object. It is actually a " +
+        std::string(detail::protect(rb_obj_classname, value)) + ".";
       throw std::runtime_error(message);
     }
 
-    WrapperBase* wrapper = getWrapper(value, rb_data_type);
+    WrapperBase* wrapper = static_cast<WrapperBase*>(RTYPEDDATA_DATA(value));
 
     if (wrapper == nullptr)
     {
-      std::string message = "Wrapped C++ object is nil. Did you override " + 
-                            std::string(detail::protect(rb_obj_classname, value)) + 
+      std::string message = "Wrapped C++ object is nil. Did you override " +
+                            std::string(detail::protect(rb_obj_classname, value)) +
                             "#initialize and forget to call super?";
 
       throw std::runtime_error(message);
     }
 
     if (takeOwnership)
+    {
       wrapper->setOwner(false);
+    }
 
-    return static_cast<T*>(wrapper->get());
+    return static_cast<T*>(wrapper->get(rb_data_type));
   }
     
   template <typename Wrapper_T>
@@ -233,12 +279,19 @@ namespace Rice::detail
   inline WrapperBase* getWrapper(VALUE value)
   {
     // Turn off spurious warning on g++ 12
-    #if defined(__GNUC__) || defined(__clang__)
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Warray-bounds"
-    #endif
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
+    if (!RTYPEDDATA_P(value))
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      detail::protect(rb_obj_classname, value),
+                      "wrapped C++ object");
+    }
 
-    return RTYPEDDATA_P(value) ? static_cast<WrapperBase*>(RTYPEDDATA_DATA(value)) : nullptr;
+    return static_cast<WrapperBase*>(RTYPEDDATA_DATA(value));
     
     #if defined(__GNUC__) || defined(__clang__)
     #pragma GCC diagnostic pop
@@ -246,21 +299,21 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner)
+  inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
   {
     using Wrapper_T = Wrapper<T*>;
-    
+
     Wrapper_T* wrapper = nullptr;
     TypedData_Get_Struct(value, Wrapper_T, rb_data_type, wrapper);
     if (wrapper)
     {
-      Registries::instance.instances.remove(wrapper->get());
+      Registries::instance.instances.remove(wrapper->get(rb_data_type));
       delete wrapper;
     }
 
-    wrapper = new Wrapper_T(data, true);
+    wrapper = new Wrapper_T(rb_data_type, data, true);
     RTYPEDDATA_DATA(value) = wrapper;
 
     Registries::instance.instances.add(data, value);
   }
-} // namespace
+}