rice 4.3.2 → 4.5.0

data/rice/detail/NativeFunction.ipp

@@ -3,38 +3,47 @@
 #include <stdexcept>
 #include <sstream>
 
-#include "cpp_protect.hpp"
-#include "to_ruby_defn.hpp"
-#include "NativeRegistry.hpp"
 
 namespace Rice::detail
 {
   template<typename Class_T, typename Function_T, bool IsMethod>
   void NativeFunction<Class_T, Function_T, IsMethod>::define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
   {
-    // Tell Ruby to invoke the static method call on this class
-    detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&NativeFunction_T::call, -1);
-
-    // Now create a NativeFunction instance and save it to the natives registry keyed on
-    // Ruby klass and method id. There may be multiple NativeFunction instances
-    // because the same C++ method could be mapped to multiple Ruby methods.
-    NativeFunction_T* native = new NativeFunction_T(klass, method_name, std::forward<Function_T>(function), methodInfo);
-    detail::Registries::instance.natives.add(klass, Identifier(method_name).id(), native);
+    // Have we defined this method yet in Ruby?
+    Identifier identifier(method_name);
+    const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, identifier.id());
+    if (natives.empty())
+    {
+      // Tell Ruby to invoke the static resolved method defined above
+      detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+    }
+
+    // Create a NativeFunction instance and save it to the NativeRegistry. There may be multiple
+    // NativeFunction instances for a specific method because C++ supports method overloading.
+    NativeFunction_T* nativeFunction = new NativeFunction_T(klass, method_name, std::forward<Function_T>(function), methodInfo);
+    std::unique_ptr<Native> native(nativeFunction);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
   }
 
+  // Ruby calls this method when invoking a proc that was defined as a C++ function
   template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::call(int argc, VALUE* argv, VALUE self)
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
   {
-    // Look up the native function based on the Ruby klass and method id
-    NativeFunction_T* nativeFunction = detail::Registries::instance.natives.lookup<NativeFunction_T*>();
+    NativeFunction_T* native = (NativeFunction_T*)callback_arg;
+    return (*native)(argc, argv, Qnil);
+  }
 
-    // Execute the function but make sure to catch any C++ exceptions!
-    return cpp_protect([&]
-    {
-      return nativeFunction->operator()(argc, argv, self);
-    });
+  // Ruby calls this method if an instance f a NativeFunction is owned by a Ruby proc. That happens when C++
+  // returns a function back to Ruby
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  {
+    NativeFunction_T* native = (NativeFunction_T*)callback_arg;
+    delete native;
+    return Qnil;
   }
 
+
   template<typename Class_T, typename Function_T, bool IsMethod>
   NativeFunction<Class_T, Function_T, IsMethod>::NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
     : klass_(klass), method_name_(method_name), function_(function), methodInfo_(methodInfo)
@@ -50,31 +59,37 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  template<typename T, std::size_t I>
-  From_Ruby<T> NativeFunction<Class_T, Function_T, IsMethod>::createFromRuby()
+  NativeFunction<Class_T, Function_T, IsMethod>::NativeFunction(Function_T function)
+    : NativeFunction(Qnil, "", function, new MethodInfo(arity))
   {
-    // Does the From_Ruby instantiation work with Arg?
-    if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
+  }
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  To_Ruby<typename NativeFunction<Class_T, Function_T, IsMethod>::To_Ruby_T> NativeFunction<Class_T, Function_T, IsMethod>::createToRuby()
+  {
+    // Does the From_Ruby instantiation work with ReturnInfo?
+    if constexpr (std::is_constructible_v<To_Ruby<To_Ruby_T>, Return*>)
     {
-      return From_Ruby<T>(&this->methodInfo_->arg(I));
+      return To_Ruby<To_Ruby_T>(&this->methodInfo_->returnInfo);
     }
     else
     {
-      return From_Ruby<T>();
+      return To_Ruby<To_Ruby_T>();
     }
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  To_Ruby<typename NativeFunction<Class_T, Function_T, IsMethod>::Return_T> NativeFunction<Class_T, Function_T, IsMethod>::createToRuby()
+  template<typename T, std::size_t I>
+  From_Ruby<T> NativeFunction<Class_T, Function_T, IsMethod>::createFromRuby()
   {
-    // Does the From_Ruby instantiation work with ReturnInfo?
-    if constexpr (std::is_constructible_v<To_Ruby<Return_T>, Return*>)
+    // Does the From_Ruby instantiation work with Arg?
+    if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
     {
-      return To_Ruby<Return_T>(&this->methodInfo_->returnInfo);
+      return From_Ruby<T>(this->methodInfo_->arg(I));
     }
     else
     {
-      return To_Ruby<Return_T>();
+      return From_Ruby<T>();
     }
   }
 
@@ -86,28 +101,134 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  std::vector<VALUE> NativeFunction<Class_T, Function_T, IsMethod>::getRubyValues(int argc, VALUE* argv)
+  Resolved NativeFunction<Class_T, Function_T, IsMethod>::matches(int argc, const VALUE* argv, VALUE self)
   {
-    // Setup a tuple for the leading rb_scan_args arguments
-    std::string scanFormat = this->methodInfo_->formatString();
-    std::tuple<int, VALUE*, const char*> rbScanArgs = std::forward_as_tuple(argc, argv, scanFormat.c_str());
-
-    // Create a vector to store the VALUEs that will be returned by rb_scan_args
-    std::vector<VALUE> rbScanValues(std::tuple_size_v<Arg_Ts>, Qnil);
-
-    // Convert the vector to an array so it can be concatenated to a tuple. As importantly
-    // fill it with pointers to rbScanValues
-    std::array<VALUE*, std::tuple_size_v<Arg_Ts>> rbScanValuePointers;
-    std::transform(rbScanValues.begin(), rbScanValues.end(), rbScanValuePointers.begin(),
-      [](VALUE& value)
+    // Return false if Ruby provided more arguments than the C++ method takes
+    if (argc > arity)
+      return Resolved{ Convertible::None, 0, this };
+
+    Resolved result { Convertible::Exact, 1, this };
+
+    MethodInfo* methodInfo = this->methodInfo_.get();
+    int index = 0;
+
+    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv, false);
+
+    // Loop over each FromRuby instance
+    for_each_tuple(this->fromRubys_,
+      [&](auto& fromRuby)
       {
-        return &value;
+        Convertible convertible = Convertible::None;
+
+        const Arg* arg = methodInfo->arg(index);
+
+        // Is a VALUE being passed directly to C++ ?
+        if (arg->isValue() && index < rubyValues.size())
+        {
+          convertible = Convertible::Exact;
+        }
+        // If index is less than argc then check with FromRuby if the VALUE is convertible
+        // to C++.
+        else if (index < rubyValues.size())
+        {
+          VALUE value = rubyValues[index];
+          convertible = fromRuby.is_convertible(value);
+        }
+        // Last check if a default value has been set
+        else if (arg->hasDefaultValue())
+        {
+          convertible = Convertible::Exact;
+        }
+
+        result.convertible = result.convertible & convertible;
+
+        index++;
       });
 
-    // Combine the tuples and call rb_scan_args
-    std::apply(rb_scan_args, std::tuple_cat(rbScanArgs, rbScanValuePointers));
+    if constexpr (arity > 0)
+      result.parameterMatch = rubyValues.size() / (double)arity;
+
+    return result;
+  }
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  std::vector<VALUE> NativeFunction<Class_T, Function_T, IsMethod>::getRubyValues(int argc, const VALUE* argv, bool validate)
+  {
+    std::vector<VALUE> result;
+
+    // Keyword handling
+    if (rb_keyword_given_p())
+    {
+      // Keywords are stored in the last element in a hash
+      int actualArgc = argc - 1;
+
+      VALUE value = argv[actualArgc];
+      Hash keywords(value);
+
+      result.resize(actualArgc + keywords.size());
+
+      // Copy over leading arguments
+      for (int i = 0; i < actualArgc; i++)
+      {
+        result[i] = argv[i];
+      }
 
-    return rbScanValues;
+      // Copy over keyword arguments
+      for (auto pair : keywords)
+      {
+        Symbol key(pair.first);
+        const Arg* arg = this->methodInfo_->arg(key.str());
+        if (!arg)
+        {
+          throw std::invalid_argument("Unknown keyword: " + key.str());
+        }
+        result[arg->position] = pair.second.value();
+      }
+    }
+    else
+    {
+      std::copy(argv, argv + argc, std::back_inserter(result));
+    }
+     
+    // Block handling. If we find a block and the last parameter is missing then
+    // set it to the block
+    if (rb_block_given_p() && result.size() < std::tuple_size_v<Arg_Ts>)
+    {
+      VALUE proc = rb_block_proc();
+      result.push_back(proc);
+    }
+
+    if (validate)
+    {
+      this->methodInfo_->verifyArgCount(result.size());
+    }
+    
+    return result;
+  }
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<typename Arg_T, int I>
+  Arg_T NativeFunction<Class_T, Function_T, IsMethod>::getNativeValue(std::vector<VALUE>& values)
+  {
+    /* In general the compiler will convert T to const T, but that does not work for converting
+       T** to const T** (see see https://isocpp.org/wiki/faq/const-correctness#constptrptr-conversion)
+       which comes up in the OpenCV bindings.
+     
+       An alternative solution is updating From_Ruby#convert to become a templated function that specifies
+       the return type. That works but requires a lot more code changes for this one case and is not 
+       backwards compatible. */
+
+    // If the user did provide a value assume Qnil
+    VALUE value = I < values.size() ? values[I] : Qnil;
+
+    if constexpr (is_pointer_pointer_v<Arg_T> && !std::is_convertible_v<remove_cv_recursive_t<Arg_T>, Arg_T>)
+    {
+      return (Arg_T)std::get<I>(this->fromRubys_).convert(value);
+    }
+    else
+    {
+      return std::get<I>(this->fromRubys_).convert(value);
+    }
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
@@ -115,10 +236,12 @@ namespace Rice::detail
   typename NativeFunction<Class_T, Function_T, IsMethod>::Arg_Ts NativeFunction<Class_T, Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
      std::index_sequence<I...>& indices)
   {
-    // Convert each Ruby value to its native value by calling the appropriate fromRuby instance.
-    // Note that for fundamental types From_Ruby<Arg_Ts> will keep a copy of the native value
-    // so it can be passed by reference or pointer to a native function.
-    return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(values[I])...);
+    /* Loop over each value returned from Ruby and convert it to the appropriate C++ type based
+       on the arguments (Arg_Ts) required by the C++ function. Arg_T may have const/volatile while
+       the associated From_Ruby<T> template parameter will not. Thus From_Ruby produces non-const values 
+       which we let the compiler convert to const values as needed. This works except for 
+       T** -> const T**, see comment in getNativeValue method. */
+    return std::forward_as_tuple(this->getNativeValue<std::tuple_element_t<I, Arg_Ts>, I>(values)...);
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
@@ -140,11 +263,19 @@ namespace Rice::detail
        that was wrapped so it can correctly extract the C++ object from 
        the Ruby object. */
     else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> && 
-                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T>)
+                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_pointer_v<Receiver_T>)
     {
       Class_T* instance = From_Ruby<Class_T*>().convert(self);
       return dynamic_cast<Receiver_T>(instance);
     }
+    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_reference_v<Receiver_T>)
+    {
+      Class_T& instance = From_Ruby<Class_T&>().convert(self);
+      return dynamic_cast<Receiver_T>(instance);
+    }
     // Self parameter could be derived from Object or it is an C++ instance and
     // needs to be unwrapped from Ruby
     else
@@ -154,17 +285,17 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeFunction(const Arg_Ts& nativeArgs)
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeFunction(Arg_Ts&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->function_, nativeArgs);
+      std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
       return Qnil;
     }
     else
     {
       // Call the native method and get the result
-      Return_T nativeResult = std::apply(this->function_, nativeArgs);
+      Return_T nativeResult = std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
 
       // Return the result
       return this->toRuby_.convert(nativeResult);
@@ -172,19 +303,19 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs)
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs)
   {
     Receiver_T receiver = this->getReceiver(self);
-    auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), nativeArgs);
+    auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), std::forward<Arg_Ts>(nativeArgs));
 
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->function_, selfAndNativeArgs);
+      std::apply(this->function_, std::forward<decltype(selfAndNativeArgs)>(selfAndNativeArgs));
       return Qnil;
     }
     else
     {
-      Return_T nativeResult = (Return_T)std::apply(this->function_, selfAndNativeArgs);
+      Return_T nativeResult = std::apply(this->function_, std::forward<decltype(selfAndNativeArgs)>(selfAndNativeArgs));
 
       // Special handling if the method returns self. If so we do not want
       // to create a new Ruby wrapper object and instead return self.
@@ -235,6 +366,10 @@ namespace Rice::detail
   template<typename Class_T, typename Function_T, bool IsMethod>
   void NativeFunction<Class_T, Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues)
   {
+    // Self will be Qnil for wrapped procs
+    if (self == Qnil)
+      return;
+
     // selfWrapper will be nullptr if this(self) is a builtin type and not an external(wrapped) type
     // it is highly unlikely that keepAlive is used in this case but we check anyway
     Wrapper* selfWrapper = getWrapper(self);
@@ -271,10 +406,10 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::operator()(int argc, VALUE* argv, VALUE self)
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::operator()(int argc, const VALUE* argv, VALUE self)
   {
-    // Get the ruby values
-    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv);
+    // Get the ruby values and make sure we have the correct number
+    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv, true);
 
     auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
 
@@ -285,11 +420,11 @@ namespace Rice::detail
     VALUE result = Qnil;
     if constexpr (std::is_same_v<Receiver_T, std::nullptr_t>)
     {
-      result = this->invokeNativeFunction(nativeValues);
+      result = this->invokeNativeFunction(std::forward<Arg_Ts>(nativeValues));
     }
     else
     {
-      result = this->invokeNativeMethod(self, nativeValues);
+      result = this->invokeNativeMethod(self, std::forward<Arg_Ts>(nativeValues));
     }
 
     // Check if any function arguments or return values need to have their lifetimes tied to the receiver

data/rice/detail/NativeIterator.hpp

@@ -1,26 +1,23 @@
-#ifndef Rice_NativeIterator__hpp_
-#define Rice_NativeIterator__hpp_
-
-#include "../traits/function_traits.hpp"
+#ifndef Rice__NativeIterator__hpp_
+#define Rice__NativeIterator__hpp_
 
 namespace Rice::detail
 {
   template<typename T, typename Iterator_Func_T>
-  class NativeIterator
+  class NativeIterator: Native
   {
   public:
     using NativeIterator_T = NativeIterator<T, Iterator_Func_T>;
     using Iterator_T = typename function_traits<Iterator_Func_T>::return_type;
     using Value_T = typename std::iterator_traits<Iterator_T>::value_type;
+    using Reference_T = typename std::iterator_traits<Iterator_T>::reference;
     using Difference_T = typename std::iterator_traits<Iterator_T>::difference_type;
+    using To_Ruby_T = remove_cv_recursive_t<Reference_T>;
 
   public:
     // Register function with Ruby
     void static define(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);
 
-    // Static member function that Ruby calls
-    static VALUE call(VALUE self);
-
   public:
     // Disallow creating/copying/moving
     NativeIterator() = delete;
@@ -29,7 +26,8 @@ namespace Rice::detail
     void operator=(const NativeIterator_T&) = delete;
     void operator=(NativeIterator_T&&) = delete;
 
-    VALUE operator()(VALUE self);
+    Resolved matches(int argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
 
   protected:
     NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);
@@ -44,6 +42,5 @@ namespace Rice::detail
     Iterator_Func_T end_;
   };
 }
-#include "NativeIterator.ipp"
 
-#endif // Rice_NativeIterator__hpp_
+#endif // Rice__NativeIterator__hpp_

data/rice/detail/NativeIterator.ipp

@@ -2,34 +2,21 @@
 #include <functional>
 #include <type_traits>
 
-#include "cpp_protect.hpp"
-#include "NativeRegistry.hpp"
-
 namespace Rice::detail
 {
   template <typename T, typename Iterator_Func_T>
   inline void NativeIterator<T, Iterator_Func_T>::define(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end)
   {
-    // Tell Ruby to invoke the static method call on this class
-    detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&NativeIterator_T::call, 0);
-
-    // Now create a NativeIterator instance and save it to the natives registry keyed on
-    // Ruby klass and method id. There may be multiple NativeIterator instances
-    // because the same C++ method could be mapped to multiple Ruby methods.
-    NativeIterator_T* native = new NativeIterator_T(klass, method_name, begin, end);
-    detail::Registries::instance.natives.add(klass, Identifier(method_name).id(), native);
-  }
+    // Tell Ruby to invoke the resolveIterator static method defined in Native super class.
+    detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
 
-  template<typename T, typename Iterator_Func_T>
-  inline VALUE NativeIterator<T, Iterator_Func_T>::call(VALUE self)
-  {
-    // Look up the native function based on the Ruby klass and method id
-    NativeIterator_T* nativeIterator = detail::Registries::instance.natives.lookup<NativeIterator_T*>();
+    // Create a NativeIterator instance and save it to the NativeRegistry. There may be multiple
+    // NativeFunction instances for a specific method because C++ supports method overloading.
+    NativeIterator_T* nativeIterator = new NativeIterator_T(klass, method_name, begin, end);
+    std::unique_ptr<Native> native(nativeIterator);
 
-    return cpp_protect([&]
-    {
-      return nativeIterator->operator()(self);
-    });
+    Identifier identifier(method_name);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
   }
 
   template <typename T, typename Iterator_Func_T>
@@ -38,6 +25,12 @@ namespace Rice::detail
   {
   }
 
+  template<typename T, typename Iterator_Func_T>
+  inline Resolved NativeIterator<T, Iterator_Func_T>::matches(int argc, const VALUE* argv, VALUE self)
+  {
+    return Resolved{ Convertible::Exact, 1.0, this };
+  }
+
   template<typename T, typename Iterator_Func_T>
   inline VALUE NativeIterator<T, Iterator_Func_T>::createRubyEnumerator(VALUE self)
   {
@@ -48,12 +41,13 @@ namespace Rice::detail
       return cpp_protect([&]
       {
         // Get the iterator instance
-        using Iter_T = NativeIterator<T, Iterator_Func_T>;
         // Class is easy
         VALUE klass = protect(rb_class_of, recv);
         // Read the method_id from an attribute we added to the enumerator instance
-        ID method_id = protect(rb_ivar_get, eobj, rb_intern("rice_method"));
-        Iter_T* iterator = detail::Registries::instance.natives.lookup<Iter_T*>(klass, method_id);
+        Identifier identifier = protect(rb_ivar_get, eobj, rb_intern("rice_method"));
+
+        const std::vector<std::unique_ptr<Native>>& natives = detail::Registries::instance.natives.lookup(klass, identifier.id());
+        NativeIterator_T* iterator = static_cast<NativeIterator_T*>(natives.back().get());
 
         // Get the wrapped C++ instance
         T* receiver = detail::From_Ruby<T*>().convert(recv);
@@ -67,19 +61,18 @@ namespace Rice::detail
       });
     };
 
-    VALUE method_sym = Identifier(this->method_name_).to_sym();
-    VALUE enumerator = protect(rb_enumeratorize_with_size, self, method_sym, 0, nullptr, rb_size_function);
+    Identifier identifier(this->method_name_);
+    VALUE enumerator = protect(rb_enumeratorize_with_size, self, identifier.to_sym(), 0, nullptr, rb_size_function);
     
     // Hack the enumerator object by storing name_ on the enumerator object so
     // the rb_size_function above has access to it
-    ID method_id = Identifier(this->method_name_).id();
-    protect(rb_ivar_set, enumerator, rb_intern("rice_method"), method_id);
+    protect(rb_ivar_set, enumerator, rb_intern("rice_method"), identifier.id());
 
     return enumerator;
   }
 
   template<typename T, typename Iterator_Func_T>
-  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(VALUE self)
+  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(int argc, const VALUE* argv, VALUE self)
   {
     if (!protect(rb_block_given_p))
     {
@@ -87,13 +80,16 @@ namespace Rice::detail
     }
     else
     {
-      T* receiver = detail::From_Ruby<T*>().convert(self);
+      detail::From_Ruby<T*> fromRuby;
+      T* receiver = fromRuby.convert(self);
+
       Iterator_T it = std::invoke(this->begin_, *receiver);
       Iterator_T end = std::invoke(this->end_, *receiver);
 
+      detail::To_Ruby<To_Ruby_T> toRuby;
       for (; it != end; ++it)
       {
-        protect(rb_yield, detail::To_Ruby<Value_T&>().convert(*it));
+        protect(rb_yield, toRuby.convert(*it));
       }
 
       return self;

data/rice/detail/NativeRegistry.hpp

@@ -1,32 +1,39 @@
 #ifndef Rice__detail__NativeRegistry__hpp
 #define Rice__detail__NativeRegistry__hpp
 
-#include <unordered_map>
-#include <any>
-#include <tuple>
-
-#include "ruby.hpp"
+#include <map>
+#include <memory>
+#include <utility>
 
+/* The Native Registry tracks C++ instance that are used to invoke C++ methods for Ruby. 
+   These objects include instances of the NativeFunction, NativeIterator, NativeAttributeGet
+   and NativeAttributeSet Each instance is specialized to call a specific C++ function, method
+   or attribute that is exposed to Ruby.
+   
+   The registry stores these C++ instances using a map of vectors. The map is keyed on the 
+   the Ruby class (VALUE) and method id (ID). The value is a vector of Native pointers stored
+   in a std::unique_ptr. Thus the registry takes ownership of the pointers when calling
+   code adds them to the registry. The value is a vector to support C++ method overloading.
+   
+   Note - when an existing Ruby class is redefined using rb_define_class, its VALUE stays the same
+   but all its methods and fields are reset. Thus any call to rb_define_class must be followed
+   by calling the reset method on the registry. Although redefinition shouldn't happen in 
+   production code it happens in many places in the unit tests. */
+   
 namespace Rice::detail
 {
   class NativeRegistry
   {
   public:
-    // Add a new native callable object keyed by Ruby class and method_id
-    void add(VALUE klass, ID method_id, std::any callable);
-
-    // Returns the Rice data for the currently active Ruby method
-    template <typename Return_T>
-    Return_T lookup();
-
-    template <typename Return_T>
-    Return_T lookup(VALUE klass, ID method_id);
+    void add(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
+    void reset(VALUE klass);
+    const std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
 
   private:
-    size_t key(VALUE klass, ID method_id);
-    std::unordered_multimap<size_t, std::tuple<VALUE, ID, std::any>> natives_ = {};
+    // Key - Ruby klass/method
+    // Value - Vector of Native pointers owned by the registry (thus wrapped in std::unique_ptr)
+    std::map<std::pair<VALUE, ID>, std::vector<std::unique_ptr<Native>>> natives_ = {};
   };
 }
-#include "NativeRegistry.ipp"
 
 #endif // Rice__detail__NativeRegistry__hpp