rice 4.3.3 → 4.6.0

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(size_t 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()(size_t argc, const VALUE* argv, VALUE self)
   {
     if (!protect(rb_block_given_p))
     {
@@ -87,16 +80,25 @@ 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;
     }
   }
+
+  template<typename T, typename Iterator_Func_T>
+  inline std::string NativeIterator<T, Iterator_Func_T>::toString()
+  {
+    return "";
+  }
 }

data/rice/detail/NativeRegistry.hpp

@@ -1,30 +1,39 @@
 #ifndef Rice__detail__NativeRegistry__hpp
 #define Rice__detail__NativeRegistry__hpp
 
-#include <unordered_map>
-#include <any>
-
-#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:
-    std::unordered_multimap<ID, std::pair<VALUE, 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

data/rice/detail/NativeRegistry.ipp

@@ -1,74 +1,49 @@
 
-// Ruby 2.7 now includes a similarly named macro that uses templates to
-// pick the right overload for the underlying function. That doesn't work
-// for our cases because we are using this method dynamically and get a
-// compilation error otherwise. This removes the macro and lets us fall
-// back to the C-API underneath again.
-#undef rb_define_method_id
-
-#include "RubyFunction.hpp"
-
 namespace Rice::detail
 {
-  inline void NativeRegistry::add(VALUE klass, ID method_id, std::any callable)
+  inline void NativeRegistry::add(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
   {
     if (rb_type(klass) == T_ICLASS)
     {
       klass = detail::protect(rb_class_of, klass);
     }
 
-    auto range = this->natives_.equal_range(method_id);
-    for (auto it = range.first; it != range.second; ++it)
-    {
-      const auto [k, d] = it->second;
+    // Create the key
+    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
 
-      if (k == klass)
-      {
-        std::get<1>(it->second) = callable;
-        return;
-      }
-    }
+    // Lookup items for method
+    std::vector<std::unique_ptr<Native>>& natives = this->natives_[key];
 
-    this->natives_.emplace(std::make_pair(method_id, std::make_pair(klass, callable)));
+    natives.push_back(std::move(native));
   }
 
-  template <typename Return_T>
-  inline Return_T NativeRegistry::lookup()
+  inline void NativeRegistry::reset(VALUE klass)
   {
-    ID method_id;
-    VALUE klass;
-    if (!rb_frame_method_id_and_class(&method_id, &klass))
+    for (auto iter = this->natives_.begin(); iter != this->natives_.end();)
     {
-      rb_raise(rb_eRuntimeError, "Cannot get method id and class for function");
+      // Iter points to a std::pair<std::pair<VALUE, ID>, std::vector<NativeRegistryItem>
+      if (iter->first.first == klass)
+      {
+        iter = this->natives_.erase(iter);
+      }
+      else
+      {
+        ++iter;
+      }
     }
-
-    return this->lookup<Return_T>(klass, method_id);
   }
-
-  template <typename Return_T>
-  inline Return_T NativeRegistry::lookup(VALUE klass, ID method_id)
+  
+  inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)
     {
       klass = detail::protect(rb_class_of, klass);
     }
 
-    auto range = this->natives_.equal_range(method_id);
-    for (auto it = range.first; it != range.second; ++it)
-    {
-      const auto [k, d] = it->second;
-
-      if (k == klass)
-      {
-        auto* ptr = std::any_cast<Return_T>(&d);
-        if (!ptr)
-        {
-          rb_raise(rb_eRuntimeError, "Unexpected return type for %s#%s", rb_class2name(klass), rb_id2name(method_id));
-        }
-        return *ptr;
-      }
-    }
+    // Create the key
+    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
 
-    rb_raise(rb_eRuntimeError, "Could not find data for klass and method id");
+    // Lookup items for method
+    return this->natives_[key];
   }
 }

data/rice/detail/Proc.hpp

@@ -0,0 +1,4 @@
+#ifndef Rice__Proc__hpp_
+#define Rice__Proc__hpp_
+
+#endif // Rice__Proc__hpp_

data/rice/detail/Proc.ipp

@@ -0,0 +1,85 @@
+namespace Rice::detail
+{
+  // Note Return_T(Arg_Ts...) is intentional versus Return_T(*)(Arg_Ts...). That is
+  // because the Type machinery strips all pointers/references/const/val etc to avoid
+  // having an explosion of Type definitions
+  template<typename Return_T, typename ...Arg_Ts>
+  struct Type<Return_T(Arg_Ts...)>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  // Wraps a C++ function as a Ruby proc
+  template<typename Return_T, typename ...Arg_Ts>
+  class To_Ruby<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Proc_T = Return_T(*)(Arg_Ts...);
+
+    VALUE convert(Proc_T proc)
+    {
+      using NativeFunction_T = NativeFunction<void, Proc_T, false>;
+      auto native = new NativeFunction_T(proc);
+      VALUE result = rb_proc_new(NativeFunction_T::procEntry, (VALUE)native);
+
+      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
+      VALUE finalizer = rb_proc_new(NativeFunction_T::finalizerCallback, (VALUE)native);
+      rb_define_finalizer(result, finalizer);
+
+      return result;
+    }
+  };
+
+  // Makes a Ruby proc callable as C callback
+  template<typename Return_T, typename ...Arg_Ts>
+  class From_Ruby<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Callback_T = Return_T(*)(Arg_Ts...);
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (protect(rb_obj_is_proc, value) == Qtrue || protect(rb_proc_lambda_p, value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return Convertible::None;
+      }
+    }
+
+#ifdef HAVE_LIBFFI
+    Callback_T convert(VALUE value)
+    {
+      using NativeCallback_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+      NativeCallback_T* nativeCallback = new NativeCallback_T(value);
+
+      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
+      VALUE finalizer = rb_proc_new(NativeCallback_T::finalizerCallback, (VALUE)nativeCallback);
+      rb_define_finalizer(value, finalizer);
+
+      return nativeCallback->callback();
+    }
+#else
+    Callback_T convert(VALUE value)
+    {
+      using NativeCallback_T = NativeCallbackSimple<Return_T(*)(Arg_Ts...)>;
+      NativeCallback_T::proc = value;
+      return &NativeCallback_T::callback;
+    }
+#endif
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+}

data/rice/detail/Registries.hpp

@@ -1,11 +1,6 @@
 #ifndef Rice__Registries__hpp_
 #define Rice__Registries__hpp_
 
-#include "HandlerRegistry.hpp"
-#include "InstanceRegistry.hpp"
-#include "NativeRegistry.hpp"
-#include "TypeRegistry.hpp"
-
 namespace Rice::detail
 {
   class Registries
@@ -21,6 +16,4 @@ namespace Rice::detail
   };
 }
 
-#include "Registries.ipp"
-
 #endif // Rice__Registries__hpp_

data/rice/detail/Registries.ipp

@@ -2,22 +2,4 @@ namespace Rice::detail
 {
   //Initialize static variables here.
   inline Registries Registries::instance;
-
-  // TODO - Big hack here but this code is dependent on internals
-  template<typename T>
-  bool Type<T>::verify()
-  {
-    // Use intrinsic_type so that we don't have to define specializations
-    // for pointers, references, const, etc.
-    using Intrinsic_T = intrinsic_type<T>;
-
-    if constexpr (std::is_fundamental_v<Intrinsic_T>)
-    {
-      return true;
-    }
-    else
-    {
-      return Registries::instance.types.verifyDefined<Intrinsic_T>();
-    }
-  }
 }

data/rice/detail/RubyFunction.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__ruby_function__hpp_
 #define Rice__detail__ruby_function__hpp_
 
-#include "ruby.hpp"
-
 namespace Rice::detail
 {
   /* This is functor class that wraps calls to a Ruby C API method. It is needed because
@@ -29,6 +27,5 @@ namespace Rice::detail
   template<typename Function_T, typename ...Arg_Ts>
   auto protect(Function_T func, Arg_Ts...args);
 }
-#include "RubyFunction.ipp"
 
 #endif // Rice__detail__ruby_function__hpp_

data/rice/detail/RubyFunction.ipp

@@ -1,5 +1,3 @@
-#include "Jump_Tag.hpp"
-#include "../Exception_defn.hpp"
 
 #include <any>
 
@@ -14,9 +12,6 @@ namespace Rice::detail
   template<typename Function_T, typename...Arg_Ts>
   inline typename RubyFunction<Function_T, Arg_Ts...>::Return_T RubyFunction<Function_T, Arg_Ts...>::operator()()
   {
-    const int TAG_RAISE = 0x6; // From Ruby header files
-    int state = 0;
-
     // Setup a thread local variable to capture the result of the Ruby function call.
     // We use thread_local because the lambda has to be captureless so it can
     // be converted to a function pointer callable by C.
@@ -45,10 +40,11 @@ namespace Rice::detail
     };
 
     // Now call rb_protect which will invoke the callback lambda above
+    int state = (int)JumpException::RUBY_TAG_NONE;
     rb_protect(callback, (VALUE)this, &state);
 
     // Did anything go wrong?
-    if (state == 0)
+    if (state == JumpException::RUBY_TAG_NONE)
     {
       if constexpr (!std::is_same_v<Return_T, void>)
       {
@@ -58,14 +54,14 @@ namespace Rice::detail
     else
     {
       VALUE err = rb_errinfo();
-      if (state == TAG_RAISE && RB_TEST(err))
+      if (state == JumpException::RUBY_TAG_RAISE && RB_TEST(err))
       {
         rb_set_errinfo(Qnil);
         throw Rice::Exception(err);
       }
       else
       {
-        throw Jump_Tag(state);
+        throw Rice::JumpException((Rice::JumpException::ruby_tag_type)state);
       }
     }
   }

data/rice/detail/RubyType.hpp

@@ -0,0 +1,16 @@
+#ifndef Rice__detail__ruby__type__hpp_
+#define Rice__detail__ruby__type__hpp_
+
+#include <set>
+
+namespace Rice::detail
+{
+  template <typename T>
+  class RubyType
+  {
+  };
+
+  void define_ruby_types();
+}
+
+#endif // Rice__detail__ruby__type__hpp_