rice 4.3.2 → 4.5.0

data/rice/detail/NativeAttributeGet.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__detail__Native_Attribute_Get__hpp_
+#define Rice__detail__Native_Attribute_Get__hpp_
+
+namespace Rice
+{
+  enum class AttrAccess
+  {
+    ReadWrite,
+    Read,
+    Write
+  };
+
+  namespace detail
+  {
+    template<typename Attribute_T>
+    class NativeAttributeGet: Native
+    {
+    public:
+      using NativeAttribute_T = NativeAttributeGet<Attribute_T>;
+
+      using T = typename attribute_traits<Attribute_T>::attr_type;
+      using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
+      using To_Ruby_T = remove_cv_recursive_t<T>;
+
+    public:
+      // Register attribute getter with Ruby
+      static void define(VALUE klass, std::string name, Attribute_T attribute);
+
+    public:
+      // Disallow creating/copying/moving
+      NativeAttributeGet() = delete;
+      NativeAttributeGet(const NativeAttribute_T&) = delete;
+      NativeAttributeGet(NativeAttribute_T&&) = delete;
+      void operator=(const NativeAttribute_T&) = delete;
+      void operator=(NativeAttribute_T&&) = delete;
+
+      Resolved matches(int argc, const VALUE* argv, VALUE self) override;
+      VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
+
+    protected:
+      NativeAttributeGet(VALUE klass, std::string name, Attribute_T attr);
+
+    private:
+      VALUE klass_;
+      std::string name_;
+      Attribute_T attribute_;
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__Native_Attribute_Get__hpp_

data/rice/detail/NativeAttributeGet.ipp

@@ -0,0 +1,51 @@
+#include <array>
+#include <algorithm>
+
+
+namespace Rice::detail
+{
+  template<typename Attribute_T>
+  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  {
+    // 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));
+    std::unique_ptr<Native> native(nativeAttribute);
+
+    detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+
+    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
+    // matches or calls function pointer. Instead Ruby can call the static call method defined on
+    // this class (&NativeAttribute_T::get).
+    Identifier identifier(name);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+  }
+
+  template<typename Attribute_T>
+  inline Resolved NativeAttributeGet<Attribute_T>::matches(int argc, const VALUE* argv, VALUE self)
+  {
+    if (argc == 0)
+      return Resolved { Convertible::Exact, 1, this };
+    else
+      return Resolved{ Convertible::None, 0, this };
+  }
+  
+  template<typename Attribute_T>
+  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute)
+    : klass_(klass), name_(name), attribute_(attribute)
+  {
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeGet<Attribute_T>::operator()(int argc, const VALUE* argv, VALUE self)
+  {
+    if constexpr (std::is_member_object_pointer_v<Attribute_T>)
+    {
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      return To_Ruby<To_Ruby_T>().convert(nativeSelf->*attribute_);
+    }
+    else
+    {
+      return To_Ruby<To_Ruby_T>().convert(*attribute_);
+    }
+  }
+} // Rice

data/rice/detail/NativeAttributeSet.hpp

@@ -0,0 +1,43 @@
+#ifndef Rice__detail__Native_Attribute_Set__hpp_
+#define Rice__detail__Native_Attribute_Set__hpp_
+
+namespace Rice
+{
+  namespace detail
+  {
+    template<typename Attribute_T>
+    class NativeAttributeSet: Native
+    {
+    public:
+      using NativeAttribute_T = NativeAttributeSet<Attribute_T>;
+      using Attr_T = typename attribute_traits<Attribute_T>::attr_type;
+      using T_Unqualified = remove_cv_recursive_t<Attr_T>;
+      using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
+
+    public:
+      // Register attribute getter/setter with Ruby
+      static void define(VALUE klass, std::string name, Attribute_T attribute);
+
+    public:
+      // Disallow creating/copying/moving
+      NativeAttributeSet() = delete;
+      NativeAttributeSet(const NativeAttribute_T&) = delete;
+      NativeAttributeSet(NativeAttribute_T&&) = delete;
+      void operator=(const NativeAttribute_T&) = delete;
+      void operator=(NativeAttribute_T&&) = delete;
+
+      Resolved matches(int argc, const VALUE* argv, VALUE self) override;
+      VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
+
+    protected:
+      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);
+
+    private:
+      VALUE klass_;
+      std::string name_;
+      Attribute_T attribute_;
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__Native_Attribute_Set__hpp_

data/rice/detail/NativeAttributeSet.ipp

@@ -0,0 +1,82 @@
+#include <array>
+#include <algorithm>
+
+
+namespace Rice::detail
+{
+  template<typename Attribute_T>
+  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  {
+    // Create a NativeAttributeSet that Ruby will call to read/write C++ variables
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute));
+    std::unique_ptr<Native> native(nativeAttribute);
+
+    // Define the write method name
+    std::string setter = name + "=";
+
+    // Tell Ruby to invoke the static method write to get the attribute value
+    detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+
+    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
+    // matches or calls function pointer. Instead Ruby can call the static call method defined on
+    // this class (&NativeAttribute_T::set).
+    Identifier identifier(setter);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+  }
+
+  template<typename Attribute_T>
+  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute)
+    : klass_(klass), name_(name), attribute_(attribute)
+  {
+  }
+
+  template<typename Attribute_T>
+  inline Resolved NativeAttributeSet<Attribute_T>::matches(int argc, const VALUE* argv, VALUE self)
+  {
+    if (argc == 1)
+      return Resolved{ Convertible::Exact, 1, this };
+    else
+      return Resolved{ Convertible::None, 0, this };
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeSet<Attribute_T>::operator()(int argc, const VALUE* argv, VALUE self)
+  {
+    if constexpr (std::is_fundamental_v<intrinsic_type<Attr_T>> && std::is_pointer_v<Attr_T>)
+    {
+      static_assert(true, "An fundamental value, such as an integer, cannot be assigned to an attribute that is a pointer.");
+    }
+    else if constexpr (std::is_same_v<intrinsic_type<Attr_T>, std::string> && std::is_pointer_v<Attr_T>)
+    {
+      static_assert(true, "An string cannot be assigned to an attribute that is a pointer.");
+    }
+
+    if (argc != 1)
+    {
+      throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
+    }
+
+    VALUE value = argv[0];
+    
+    if constexpr (!std::is_null_pointer_v<Receiver_T> && 
+                  !std::is_const_v<Attr_T> && 
+                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+    {
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+    }
+    else if constexpr (std::is_null_pointer_v<Receiver_T> && 
+                       !std::is_const_v<Attr_T> &&
+                       (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+    {
+      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
+    }
+    else
+    {
+      // Should never get here because define_attr won't compile this code, but just in case!
+      throw std::invalid_argument("Could not set attribute. Attribute: " + this->name_);
+    }
+
+    return value;
+  }
+} // Rice

data/rice/detail/NativeCallbackFFI.hpp

@@ -0,0 +1,55 @@
+#ifndef Rice__detail__Native_Callback_Ffi_hpp_
+#define Rice__detail__Native_Callback_Ffi_hpp_
+
+#ifdef HAVE_LIBFFI
+
+#include <ffi.h>
+
+namespace Rice::detail
+{
+  template<typename Callback_T>
+  class NativeCallbackFFI;
+
+  template<typename Return_T, typename ...Arg_Ts>
+  class NativeCallbackFFI<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Callback_T = Return_T(Arg_Ts...);
+    using Tuple_T = std::tuple<Arg_Ts...>;
+    static void ffiCallback(ffi_cif* cif, void* ret, void* args[], void* instance);
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+    static void setMethodInfo(MethodInfo* methodInfo);
+
+  public:
+    NativeCallbackFFI(VALUE proc);
+    ~NativeCallbackFFI();
+    NativeCallbackFFI(const NativeCallbackFFI&) = delete;
+    NativeCallbackFFI(NativeCallbackFFI&&) = delete;
+    void operator=(const NativeCallbackFFI&) = delete;
+    void operator=(NativeCallbackFFI&&) = delete;
+
+    Return_T operator()(Arg_Ts...args);
+    Callback_T* callback();
+
+  private:
+    template <typename Arg_T>
+    static ffi_type* ffiType();
+
+    template<std::size_t... I>
+    static Tuple_T convertArgsToTuple(void* args[], std::index_sequence<I...>& indices);
+
+    static inline std::array<ffi_type*, sizeof...(Arg_Ts)> args_ = { ffiType<Arg_Ts>()... };
+    static inline ffi_cif cif_;
+    static inline ffi_closure* closure_ = nullptr;
+    static inline Callback_T* callback_ = nullptr;
+    static inline std::unique_ptr<MethodInfo> methodInfo_ = std::make_unique<MethodInfo>();
+
+    template<std::size_t... I>
+    Return_T callRuby(std::index_sequence<I...>& indices, Arg_Ts...args);
+  private:
+    VALUE proc_;
+  };
+}
+#endif // HAVE_LIBFFI
+
+#endif // Rice__detail__Native_Callback_Ffi_hpp_

data/rice/detail/NativeCallbackFFI.ipp

@@ -0,0 +1,151 @@
+#ifdef HAVE_LIBFFI
+#include <ffi.h>
+
+namespace Rice::detail
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  template<typename Arg_T>
+  ffi_type* NativeCallbackFFI<Return_T(*)(Arg_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 (std::is_pointer_v<Arg_T>)
+    {
+      return &ffi_type_pointer;
+    }
+    else
+    {
+      const std::type_index& key = std::type_index(typeid(Arg_T));
+      return nativeToFfiMapping[key];
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  typename NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::Tuple_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::convertArgsToTuple(void* args[], std::index_sequence<I...>& indices)
+  {
+    /* 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(*(std::tuple_element_t<I, Tuple_T>*)(args[I])...);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::ffiCallback(ffi_cif* cif, void* ret, void* args[], void* instance)
+  {
+    using Self_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+    Self_T* self = (Self_T*)instance;
+
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+
+    if constexpr (sizeof...(Arg_Ts) == 0)
+    {
+      *(Return_T*)ret = self->operator()();
+    }
+    else
+    {
+      std::tuple<Arg_Ts...> tuple = convertArgsToTuple(args, indices);
+      *(Return_T*)ret = std::apply(*self, tuple);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::setMethodInfo(MethodInfo* methodInfo)
+  {
+    methodInfo_.reset(methodInfo);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::~NativeCallbackFFI()
+  {
+    this->proc_ = Qnil;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  VALUE NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  {
+    using NativeCallback_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+    NativeCallback_T* nativeCallback = (NativeCallback_T*)callback_arg;
+    delete nativeCallback;
+    return Qnil;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::NativeCallbackFFI(VALUE proc) : proc_(proc)
+  {
+    // First setup desccription of callback
+    if (cif_.bytes == 0)
+    {
+      ffi_prep_cif(&cif_, FFI_DEFAULT_ABI, sizeof...(Arg_Ts), &ffi_type_pointer, args_.data());
+    }
+
+    // Create FFI closure
+    this->closure_ = (ffi_closure *)ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), (void**)(&this->callback_));
+    ffi_status status = ffi_prep_closure_loc(this->closure_, &cif_, ffiCallback, (void*)this, (void*)this->callback_);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  typename NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::Callback_T* NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callback()
+  {
+    return (Callback_T*)this->callback_;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  Return_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callRuby(std::index_sequence<I...>& indices, Arg_Ts...args)
+  {
+    static Identifier id("call");
+    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>(methodInfo_->arg(I)).convert(args)... };
+    VALUE result = detail::protect(rb_funcallv, this->proc_, id.id(), (int)sizeof...(Arg_Ts), values.data());
+    if constexpr (!std::is_void_v<Return_T>)
+    {
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      return fromRuby.convert(result);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::operator()(Arg_Ts...args)
+  {
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+    return NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callRuby(indices, args...);
+  }
+}
+#endif // HAVE_LIBFFI

data/rice/detail/NativeCallbackSimple.hpp

@@ -0,0 +1,30 @@
+#ifndef Rice__detail__Native_Callback_Simple_hpp_
+#define Rice__detail__Native_Callback_Simple_hpp_
+
+namespace Rice::detail
+{
+  template<typename Callback_T>
+  class NativeCallbackSimple;
+
+  template<typename Return_T, typename ...Arg_Ts>
+  class NativeCallbackSimple<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    static Return_T callback(Arg_Ts...args);
+    static inline VALUE proc = Qnil;
+    static void setMethodInfo(MethodInfo* methodInfo);
+
+  public:
+    NativeCallbackSimple()  = delete;
+    NativeCallbackSimple(const NativeCallbackSimple&) = delete;
+    NativeCallbackSimple(NativeCallbackSimple&&) = delete;
+    void operator=(const NativeCallbackSimple&) = delete;
+    void operator=(NativeCallbackSimple&&) = delete;
+
+  private:
+    template<std::size_t... I>
+    static Return_T callRuby(std::index_sequence<I...>& indices, Arg_Ts...args);
+    static inline std::unique_ptr<MethodInfo> methodInfo_ = std::make_unique<MethodInfo>();
+  };
+}
+#endif // Rice__detail__Native_Callback_Simple_hpp_

data/rice/detail/NativeCallbackSimple.ipp

@@ -0,0 +1,29 @@
+namespace Rice::detail
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::setMethodInfo(MethodInfo* methodInfo)
+  {
+    methodInfo_.reset(methodInfo);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  Return_T NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callRuby(std::index_sequence<I...>& indices, Arg_Ts...args)
+  {
+    static Identifier id("call");
+    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>(methodInfo_->arg(I)).convert(args)... };
+    VALUE result = detail::protect(rb_funcallv, proc, id.id(), (int)sizeof...(Arg_Ts), values.data());
+    if constexpr (!std::is_void_v<Return_T>)
+    {
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      return fromRuby.convert(result);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callback(Arg_Ts...args)
+  {
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+    return NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callRuby(indices, args...);
+  }
+}

data/rice/detail/NativeFunction.hpp

@@ -1,13 +1,6 @@
 #ifndef Rice__detail__Native_Function__hpp_
 #define Rice__detail__Native_Function__hpp_
 
-#include "ruby.hpp"
-#include "ExceptionHandler_defn.hpp"
-#include "MethodInfo.hpp"
-#include "../traits/function_traits.hpp"
-#include "../traits/method_traits.hpp"
-#include "from_ruby.hpp"
-
 namespace Rice::detail
 {
   //! The NativeFunction class calls C++ functions/methods/lambdas on behalf of Ruby
@@ -43,24 +36,26 @@ namespace Rice::detail
    */
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  class NativeFunction
+  class NativeFunction: Native
   {
   public:
     using NativeFunction_T = NativeFunction<Class_T, Function_T, IsMethod>;
 
     // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
     // have the concept of constants anyways
-    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
+    using Return_T = typename function_traits<Function_T>::return_type;
     using Receiver_T = typename method_traits<Function_T, IsMethod>::Class_T;
     using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
+    static constexpr std::size_t arity = method_traits<Function_T, IsMethod>::arity;
     using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+    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);
 
-    // Static member function that Ruby calls
-    static VALUE call(int argc, VALUE* argv, VALUE self);
-
+    // Proc entry
+    static VALUE procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
   public:
     // Disallow creating/copying/moving
     NativeFunction() = delete;
@@ -69,11 +64,12 @@ namespace Rice::detail
     void operator=(const NativeFunction_T&) = delete;
     void operator=(NativeFunction_T&&) = delete;
 
-    // Invokes the wrapped function
-    VALUE operator()(int argc, VALUE* argv, VALUE self);
+    Resolved matches(int argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
 
-  protected:
+    NativeFunction(Function_T function);
     NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+  protected:
 
   private:
     template<typename T, std::size_t I>
@@ -83,10 +79,14 @@ namespace Rice::detail
     template<std::size_t...I>
     From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
 
-    To_Ruby<Return_T> createToRuby();
+    // Convert C++ value to Ruby
+    To_Ruby<To_Ruby_T> createToRuby();
       
     // Convert Ruby argv pointer to Ruby values
-    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
+    std::vector<VALUE> getRubyValues(int argc, const VALUE* argv, bool validate);
+
+    template<typename Arg_T, int I>
+    Arg_T getNativeValue(std::vector<VALUE>& values);
 
     // Convert Ruby values to C++ values
     template<typename std::size_t...I>
@@ -102,18 +102,17 @@ namespace Rice::detail
     void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
 
     // Call the underlying C++ function
-    VALUE invokeNativeFunction(const Arg_Ts& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs);
+    VALUE invokeNativeFunction(Arg_Ts&& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs);
 
   private:
     VALUE klass_;
     std::string method_name_;
     Function_T function_;
     From_Ruby_Args_Ts fromRubys_;
-    To_Ruby<Return_T> toRuby_;
+    To_Ruby<To_Ruby_T> toRuby_;
     std::unique_ptr<MethodInfo> methodInfo_;
   };
 }
-#include "NativeFunction.ipp"
 
 #endif // Rice__detail__Native_Function__hpp_