rice 4.7.1 → 4.8.0

data/rice/detail/NativeAttributeGet.ipp

@@ -4,13 +4,17 @@
 namespace Rice::detail
 {
   template<typename Attribute_T>
-  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, Return returnInfo)
+  template<typename...Arg_Ts>
+  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, Arg_Ts&...args)
   {
     // Verify attribute type
-    Native::verify_type<Attr_T>(returnInfo.isBuffer());
+    Native::verify_type<Attr_T, is_one_of_v<ReturnBuffer, Arg_Ts...>>();
+
+    // Create return info
+    std::unique_ptr<Return> returnInfo = Native::create_return<Arg_Ts...>(args...);
 
     // Create a NativeAttributeGet that Ruby will call to read/write C++ variables
-    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), returnInfo);
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), std::move(returnInfo));
     std::unique_ptr<Native> native(nativeAttribute);
 
     detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
@@ -23,22 +27,23 @@ namespace Rice::detail
   }
 
   template<typename Attribute_T>
-  inline Resolved NativeAttributeGet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
+  inline Resolved NativeAttributeGet<Attribute_T>::matches(std::map<std::string, VALUE>& values)
   {
-    if (argc == 0)
-      return Resolved { Convertible::Exact, 1, this };
+    if (values.size() == 0)
+      return Resolved{ Convertible::Exact, this };
     else
-      return Resolved{ Convertible::None, 0, this };
+      return Resolved{ Convertible::None, this };
   }
   
   template<typename Attribute_T>
-  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute, Return returnInfo)
-    : klass_(klass), name_(name), attribute_(attribute), return_(returnInfo)
+  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute, std::unique_ptr<Return>&& returnInfo)
+    : Native(name, std::move(returnInfo)),
+      klass_(klass), attribute_(attribute)
   {
   }
 
   template<typename Attribute_T>
-  inline VALUE NativeAttributeGet<Attribute_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeAttributeGet<Attribute_T>::operator()(std::map<std::string, VALUE>&, VALUE self)
   {
     if constexpr (std::is_member_object_pointer_v<Attribute_T>)
     {
@@ -46,42 +51,42 @@ namespace Rice::detail
 
       if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(nativeSelf->*attribute_);
       }
       else if constexpr (std::is_array_v<To_Ruby_T>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(nativeSelf->*attribute_);
       }
       else if constexpr (std::is_pointer_v<To_Ruby_T>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(nativeSelf->*attribute_);
       }
       else
       {
         // If the attribute is an object return a reference to avoid a copy (and avoid issues with
         // attributes that are not assignable, copy constructible or move constructible)
-        return To_Ruby<To_Ruby_T&>(&this->return_).convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T&>(this->returnInfo_.get()).convert(nativeSelf->*attribute_);
       }
     }
     else
     {
       if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(*attribute_);
       }
       else if constexpr (std::is_array_v<To_Ruby_T>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(*attribute_);
       }
       else if constexpr (std::is_pointer_v<To_Ruby_T>)
       {
-        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+        return To_Ruby<To_Ruby_T>(this->returnInfo_.get()).convert(*attribute_);
       }
       else
       {
         // If the attribute is an object return a reference to avoid a copy (and avoid issues with
         // attributes that are not assignable, copy constructible or move constructible)
-        return To_Ruby<To_Ruby_T&>(&this->return_).convert(*attribute_);
+        return To_Ruby<To_Ruby_T&>(this->returnInfo_.get()).convert(*attribute_);
       }
     }
   }
@@ -92,12 +97,6 @@ namespace Rice::detail
     return "";
   }
 
-  template<typename Attribute_T>
-  inline std::string NativeAttributeGet<Attribute_T>::name()
-  {
-    return this->name_;
-  }
-
   template<typename Attribute_T>
   inline NativeKind NativeAttributeGet<Attribute_T>::kind()
   {
@@ -108,9 +107,10 @@ namespace Rice::detail
   inline VALUE NativeAttributeGet<Attribute_T>::returnKlass()
   {
     // Check if an array is being returned
-    if (this->return_.isBuffer())
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
     {
-      TypeMapper<Pointer<Attr_T>> typeMapper;
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Attr_T>>>> typeMapper;
       return typeMapper.rubyKlass();
     }
     else

data/rice/detail/NativeAttributeSet.hpp

@@ -26,11 +26,10 @@ namespace Rice
       void operator=(const NativeAttribute_T&) = delete;
       void operator=(NativeAttribute_T&&) = delete;
 
-      Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
-      VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+      Resolved matches(std::map<std::string, VALUE>& values) override;
+      VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) override;
       std::string toString() override;
 
-      std::string name() override;
       NativeKind kind() override;
       VALUE returnKlass() override;
 
@@ -39,7 +38,6 @@ namespace Rice
 
     private:
       VALUE klass_;
-      std::string name_;
       Attribute_T attribute_;
     };
   } // detail

data/rice/detail/NativeAttributeSet.ipp

@@ -26,28 +26,28 @@ namespace Rice::detail
 
   template<typename Attribute_T>
   NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute)
-    : klass_(klass), name_(name), attribute_(attribute)
+    : Native(name), klass_(klass), attribute_(attribute)
   {
   }
 
   template<typename Attribute_T>
-  inline Resolved NativeAttributeSet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
+  inline Resolved NativeAttributeSet<Attribute_T>::matches(std::map<std::string, VALUE>& values)
   {
-    if (argc == 1)
-      return Resolved{ Convertible::Exact, 1, this };
+    if (values.size() == 1)
+      return Resolved{ Convertible::Exact, this };
     else
-      return Resolved{ Convertible::None, 0, this };
+      return Resolved{ Convertible::None, this };
   }
 
   template<typename Attribute_T>
-  inline VALUE NativeAttributeSet<Attribute_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeAttributeSet<Attribute_T>::operator()(std::map<std::string, VALUE>& values, VALUE self)
   {
-    if (argc != 1)
+    if (values.size() != 1)
     {
       throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
     }
 
-    VALUE value = argv[0];
+    VALUE value = values.begin()->second;
 
     if constexpr (!std::is_null_pointer_v<Receiver_T>)
     {
@@ -77,12 +77,6 @@ namespace Rice::detail
     return "";
   }
 
-  template<typename Attribute_T>
-  inline std::string NativeAttributeSet<Attribute_T>::name()
-  {
-    return this->name_;
-  }
-
   template<typename Attribute_T>
   inline NativeKind NativeAttributeSet<Attribute_T>::kind()
   {
@@ -92,7 +86,17 @@ namespace Rice::detail
   template<typename Attribute_T>
   inline VALUE NativeAttributeSet<Attribute_T>::returnKlass()
   {
-    TypeMapper<Attr_T> typeMapper;
-    return typeMapper.rubyKlass();
+    // Check if an array is being returned
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
+    {
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Attr_T>>>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Attr_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   }
 }

data/rice/detail/NativeCallback.hpp

@@ -0,0 +1,77 @@
+#ifndef Rice__detail__Native_Callback_Ffi_hpp_
+#define Rice__detail__Native_Callback_Ffi_hpp_
+
+#ifdef HAVE_LIBFFI
+#include <ffi.h>
+#endif //HAVE_LIBFFI
+
+namespace Rice::detail
+{
+  template<typename Callback_T>
+  class NativeCallback;
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  class NativeCallback<Return_T(*)(Parameter_Ts...)> : public Native
+  {
+  public:
+    using Callback_T = Return_T(*)(Parameter_Ts...);
+    using NativeCallback_T = NativeCallback<Callback_T>;
+    using Tuple_T = std::tuple<Parameter_Ts...>;
+
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+
+    template<typename ...Arg_Ts>
+    static void define(Arg_Ts&& ...args);
+
+    static Return_T invoke(Parameter_Ts...args);
+  public:
+    NativeCallback(VALUE proc);
+    ~NativeCallback();
+    NativeCallback(const NativeCallback&) = delete;
+    NativeCallback(NativeCallback&&) = delete;
+    void operator=(const NativeCallback&) = delete;
+    void operator=(NativeCallback&&) = delete;
+
+    Callback_T callback();
+  private:
+    template<typename Parameter_T>
+    static Parameter_T extractArg(void* arg);
+
+    template<std::size_t... I>
+    static Tuple_T convertArgsToTuple(void* args[], std::index_sequence<I...>& indices);
+    Callback_T callback_ = nullptr;
+
+    template<std::size_t... I>
+    static void copyParametersImpl(std::vector<std::unique_ptr<ParameterAbstract>>& result, std::index_sequence<I...> indices);
+    static std::vector<std::unique_ptr<ParameterAbstract>> copyParameters();
+    static std::unique_ptr<Return> copyReturnInfo();
+
+    static inline std::vector<std::unique_ptr<ParameterAbstract>> parameters_;
+    static inline std::unique_ptr<Return> returnInfo_;
+    static inline NativeCallback_T* native_;
+
+  private:
+    VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) override;
+    std::string toString() override;
+    NativeKind kind() override;
+    VALUE returnKlass() override;
+
+    template<std::size_t... I>
+    Return_T callRuby(std::index_sequence<I...>& indices, Parameter_Ts...args);
+
+    VALUE proc_;
+    From_Ruby<Return_T> fromRuby_;
+
+#ifdef HAVE_LIBFFI
+    template <typename Arg_T>
+    static ffi_type* ffiType();
+
+    static void invokeFFI(ffi_cif* cif, void* ret, void* args[], void* instance);
+
+    static inline std::array<ffi_type*, sizeof...(Parameter_Ts)> args_ = { ffiType<Parameter_Ts>()... };
+    static inline ffi_cif cif_;
+    ffi_closure* closure_ = nullptr;
+#endif //HAVE_LIBFFI
+  };
+}
+#endif // Rice__detail__Native_Callback_Ffi_hpp_

data/rice/detail/NativeCallback.ipp

@@ -0,0 +1,280 @@
+namespace Rice::detail
+{
+#ifdef HAVE_LIBFFI
+  template<typename Return_T, typename ...Parameter_Ts>
+  template<typename Arg_T>
+  ffi_type* NativeCallback<Return_T(*)(Parameter_Ts...)>::ffiType()
+  {
+    std::map<std::type_index, ffi_type*> nativeToFfiMapping = { 
+      {std::type_index(typeid(bool)),               &ffi_type_uint8},
+      {std::type_index(typeid(bool)),               &ffi_type_uint8},
+      {std::type_index(typeid(char)),               &ffi_type_schar},
+      {std::type_index(typeid(unsigned char)),      &ffi_type_uchar},
+      {std::type_index(typeid(signed char)),        &ffi_type_schar},
+      {std::type_index(typeid(uint8_t)),            &ffi_type_uint8},
+      {std::type_index(typeid(unsigned short)),     &ffi_type_uint8},
+      {std::type_index(typeid(int8_t)),             &ffi_type_sint8},
+      {std::type_index(typeid(short)),              &ffi_type_sint8},
+      {std::type_index(typeid(uint16_t)),           &ffi_type_uint16},
+      {std::type_index(typeid(int16_t)),            &ffi_type_sint16},
+      {std::type_index(typeid(uint32_t)),           &ffi_type_uint32},
+      {std::type_index(typeid(unsigned int)),       &ffi_type_uint32},
+      {std::type_index(typeid(signed int)),         &ffi_type_uint32},
+      {std::type_index(typeid(int32_t)),            &ffi_type_sint32},
+      {std::type_index(typeid(uint64_t)),           &ffi_type_uint64},
+      {std::type_index(typeid(unsigned long long)), &ffi_type_uint64},
+      {std::type_index(typeid(int64_t)),            &ffi_type_sint64},
+      {std::type_index(typeid(signed long long)),   &ffi_type_sint64},
+      {std::type_index(typeid(float)),              &ffi_type_float},
+      {std::type_index(typeid(double)),             &ffi_type_double},
+      {std::type_index(typeid(void)),               &ffi_type_pointer},
+      {std::type_index(typeid(long double)),        &ffi_type_longdouble}
+    };
+
+    if (sizeof(long) == 32)
+    {
+      nativeToFfiMapping[std::type_index(typeid(unsigned long))] = &ffi_type_uint32;
+      nativeToFfiMapping[std::type_index(typeid(long))] = &ffi_type_sint32;
+    }
+    else if (sizeof(long) == 64)
+    {
+      nativeToFfiMapping[std::type_index(typeid(unsigned long))] = &ffi_type_uint64;
+      nativeToFfiMapping[std::type_index(typeid(long))] = &ffi_type_sint64;
+    }
+    
+    if constexpr (std::is_pointer_v<Arg_T> || std::is_reference_v<Arg_T>)
+    {
+      return &ffi_type_pointer;
+    }
+    else
+    {
+      const std::type_index& key = std::type_index(typeid(Arg_T));
+      return nativeToFfiMapping[key];
+    }
+  }
+
+  // This is the function provided to the C++ callback with FFI
+  template<typename Return_T, typename ...Parameter_Ts>
+  void NativeCallback<Return_T(*)(Parameter_Ts...)>::invokeFFI(ffi_cif*, void* ret, void* args[], void* instance)
+  {
+    NativeCallback_T* self = (NativeCallback_T*)instance;
+
+    // Define a helper lambda to invoke callRuby with unpacked args
+    auto indices = std::make_index_sequence<sizeof...(Parameter_Ts)>{};
+    auto helper = [&](auto&&... args)
+    {
+      if constexpr (!std::is_void_v<Return_T>)
+      {
+        *(Return_T*)ret = self->callRuby(indices, std::forward<Parameter_Ts>(args)...);
+      }
+      else
+      {
+        self->callRuby(indices, std::forward<Parameter_Ts>(args)...);
+      }
+    };
+
+    // Convert the C style array to a tuple
+    Tuple_T argsTuple = convertArgsToTuple(args, indices);
+
+    // Now use std::apply to unpack the tuple and call the lamba helper
+    std::apply(helper, std::forward<Tuple_T>(argsTuple));
+  }
+#endif //HAVE_LIBFFI
+
+  // This is the function provided to the C++ callback without FFI
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline Return_T NativeCallback<Return_T(*)(Parameter_Ts...)>::invoke(Parameter_Ts...args)
+  {
+    auto indices = std::make_index_sequence<sizeof...(Parameter_Ts)>{};
+
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      NativeCallback::native_->callRuby(indices, args...);
+    }
+    else
+    {
+      return NativeCallback::native_->callRuby(indices, args...);
+    }
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  std::vector<std::unique_ptr<ParameterAbstract>> NativeCallback<Return_T(*)(Parameter_Ts...)>::copyParameters()
+  {
+    std::vector<std::unique_ptr<ParameterAbstract>> result;
+
+    if (sizeof...(Parameter_Ts) > 0 && parameters_.empty())
+    {
+      NativeCallback_T::define();
+    }
+
+    if (parameters_.size() > 0)
+    {
+      auto indices = std::make_index_sequence<sizeof...(Parameter_Ts)>{};
+      copyParametersImpl(result, indices);
+    }
+    return result;
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  template<std::size_t... I>
+  void NativeCallback<Return_T(*)(Parameter_Ts...)>::copyParametersImpl(std::vector<std::unique_ptr<ParameterAbstract>>& result, std::index_sequence<I...>)
+  {
+    (result.push_back(std::make_unique<Parameter<Parameter_Ts>>(*(Parameter<Parameter_Ts>*)parameters_[I].get())), ...);
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  std::unique_ptr<Return> NativeCallback<Return_T(*)(Parameter_Ts...)>::copyReturnInfo()
+  {
+    if (!returnInfo_)
+    {
+      NativeCallback_T::define();
+    }
+
+    return std::make_unique<Return>(*returnInfo_);
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  template<typename Parameter_T>
+  Parameter_T NativeCallback<Return_T(*)(Parameter_Ts...)>::extractArg(void* arg)
+  {
+    if constexpr (std::is_reference_v<Parameter_T>)
+    {
+      // We told libffi to pass references as pointers, so arg points to the pointer
+      return static_cast<Parameter_T>(**reinterpret_cast<std::remove_reference_t<Parameter_T>**>(arg));
+    }
+    else
+    {
+      return *reinterpret_cast<Parameter_T*>(arg);
+    }
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  template<std::size_t... I>
+  typename NativeCallback<Return_T(*)(Parameter_Ts...)>::Tuple_T NativeCallback<Return_T(*)(Parameter_Ts...)>::convertArgsToTuple(void* args[], std::index_sequence<I...>&)
+  {
+    /* Loop over each value returned from Ruby and convert it to the appropriate C++ type based
+       on the arguments (Parameter_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 convertToNative method. */
+    return std::forward_as_tuple(extractArg<Parameter_Ts>(args[I])...);
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  VALUE NativeCallback<Return_T(*)(Parameter_Ts...)>::finalizerCallback(VALUE, VALUE callback_arg, int, const VALUE*, VALUE)
+  {
+    NativeCallback_T* nativeCallback = (NativeCallback_T*)callback_arg;
+    delete nativeCallback;
+    return Qnil;
+  }
+
+  template<typename Return_T, typename...Parameter_Ts>
+  template<typename ...Arg_Ts>
+  inline void NativeCallback<Return_T(*)(Parameter_Ts...)>::define(Arg_Ts&& ...args)
+  {
+    // Create parameters and save them in static member so we can use them later when constructing an instance
+    using Parameter_Tuple = std::tuple<Parameter_Ts...>;
+    NativeCallback_T::parameters_ = Native::create_parameters<Parameter_Tuple>(std::forward<Arg_Ts>(args)...);
+
+    // Create Return and save it in static member so we can use them later when constructing an instance
+    NativeCallback_T::returnInfo_ = Native::create_return<Arg_Ts...>(args...);
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  NativeCallback<Return_T(*)(Parameter_Ts...)>::NativeCallback(VALUE proc) :
+    Native("callback", copyReturnInfo(), copyParameters()),
+      proc_(proc), fromRuby_(returnInfo_.get())
+  {
+    // 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)this);
+    rb_define_finalizer(proc, finalizer);
+
+#ifdef HAVE_LIBFFI
+    // First setup description of callback
+    if (cif_.bytes == 0)
+    {
+      ffi_prep_cif(&cif_, FFI_DEFAULT_ABI, sizeof...(Parameter_Ts), ffiType<Return_T>(), args_.data());
+    }
+
+    // Now allocate memory
+    this->closure_ = (ffi_closure *)ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), (void**)(&this->callback_));
+    // Now create the closure which will create a C++ callback
+    ffi_prep_closure_loc(this->closure_, &cif_, invokeFFI, (void*)this, (void*)this->callback_);
+#else
+    NativeCallback_T::callback_ = &NativeCallback_T::invoke;
+    NativeCallback_T::native_ = this;
+#endif
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  NativeCallback<Return_T(*)(Parameter_Ts...)>::~NativeCallback()
+  {
+#ifdef HAVE_LIBFFI
+    ffi_closure_free(this->closure_);
+#endif
+
+    NativeCallback_T::callback_ = nullptr;
+    NativeCallback_T::native_ = nullptr;
+
+    this->proc_ = Qnil;
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  typename NativeCallback<Return_T(*)(Parameter_Ts...)>::Callback_T NativeCallback<Return_T(*)(Parameter_Ts...)>::callback()
+  {
+    return this->callback_;
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  template<std::size_t... I>
+  Return_T NativeCallback<Return_T(*)(Parameter_Ts...)>::callRuby(std::index_sequence<I...>&, Parameter_Ts...args)
+  {
+    // Convert the C++ arguments to Ruby VALUEs
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = {
+      dynamic_cast<Parameter<Parameter_Ts>*>(this->parameters_[I].get())->
+               convertToRuby(args)... };
+
+    static Identifier id("call");
+    VALUE result = detail::protect(rb_funcallv, this->proc_, id.id(), (int)sizeof...(Parameter_Ts), values.data());
+    if constexpr (!std::is_void_v<Return_T>)
+    {
+      return this->fromRuby_.convert(result);
+    }
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline VALUE NativeCallback<Return_T(*)(Parameter_Ts...)>::operator()(std::map<std::string, VALUE>&, VALUE)
+  {
+    return Qnil;
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline std::string NativeCallback<Return_T(*)(Parameter_Ts...)>::toString()
+  {
+    return "";
+  }
+
+  //NativeKind kind() override;
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline NativeKind NativeCallback<Return_T(*)(Parameter_Ts...)>::kind()
+  {
+    return NativeKind::Callback;
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline VALUE NativeCallback<Return_T(*)(Parameter_Ts...)>::returnKlass()
+  {
+    // Check if an array is being returned
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
+    {
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Return_T>>>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Return_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+  }
+}

data/rice/detail/NativeFunction.hpp

@@ -35,55 +35,45 @@ namespace Rice::detail
    *    calling them methods (self) or functions (no self).
    */
 
-  template<typename Function_T>
+  template<typename Function_T, bool NoGVL = false>
   class NativeFunction: Native
   {
   public:
-    using NativeFunction_T = NativeFunction<Function_T>;
+    using NativeFunction_T = NativeFunction<Function_T, NoGVL>;
 
     // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
     // have the concept of constants anyways
     using Return_T = typename function_traits<Function_T>::return_type;
     using Class_T = typename function_traits<Function_T>::class_type;
-    using Arg_Ts = typename function_traits<Function_T>::arg_types;
+    using Parameter_Ts = typename function_traits<Function_T>::arg_types;
     using To_Ruby_T = remove_cv_recursive_t<Return_T>;
 
-    // Register function with Ruby
-    static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+    template<typename ...Arg_Ts>
+    static void define(VALUE klass, std::string function_name, Function_T function, Arg_Ts&& ...args);
 
   public:
-    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+    NativeFunction(VALUE klass, std::string method_name, Function_T function, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
 
-    VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) override;
     std::string toString() override;
 
-    std::string name() override;
     NativeKind kind() override;
     VALUE returnKlass() override;
 
   private:
-    template<std::size_t...I>
-    std::vector<std::string> argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices);
+    std::vector<std::string> argTypeNames();
 
     // Convert Ruby values to C++ values
     template<typename std::size_t...I>
-    Arg_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
-
-    // Throw an exception when wrapper cannot be extracted
-    [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
-
-    // Do we need to keep alive any arguments?
-    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
+    Parameter_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
 
     // Call the underlying C++ function
-    VALUE invoke(Arg_Ts&& nativeArgs);
-    VALUE invokeNoGVL(Arg_Ts&& nativeArgs);
+    VALUE invoke(Parameter_Ts&& nativeArgs);
+    VALUE invokeNoGVL(Parameter_Ts&& nativeArgs);
 
   private:
     VALUE klass_;
-    std::string method_name_;
     Function_T function_;
-    std::unique_ptr<MethodInfo> methodInfo_;
     To_Ruby<To_Ruby_T> toRuby_;
   };
 }