rice 4.5.0 → 4.6.1

data/rice/detail/NativeAttributeGet.ipp

@@ -21,7 +21,7 @@ namespace Rice::detail
   }
 
   template<typename Attribute_T>
-  inline Resolved NativeAttributeGet<Attribute_T>::matches(int argc, const VALUE* argv, VALUE self)
+  inline Resolved NativeAttributeGet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
   {
     if (argc == 0)
       return Resolved { Convertible::Exact, 1, this };
@@ -36,16 +36,33 @@ namespace Rice::detail
   }
 
   template<typename Attribute_T>
-  inline VALUE NativeAttributeGet<Attribute_T>::operator()(int argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeAttributeGet<Attribute_T>::operator()(size_t 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_);
+
+      if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>> ||
+                    (std::is_array_v<To_Ruby_T> && std::is_fundamental_v<std::remove_extent_t<To_Ruby_T>>))
+      {
+        return To_Ruby<To_Ruby_T>().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&>().convert(nativeSelf->*attribute_);
+      }
     }
     else
     {
       return To_Ruby<To_Ruby_T>().convert(*attribute_);
     }
   }
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeGet<Attribute_T>::toString()
+  {
+    return "";
+  }
 } // Rice

data/rice/detail/NativeAttributeSet.hpp

@@ -26,8 +26,9 @@ namespace Rice
       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;
+      Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+      VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+      std::string toString() override;
 
     protected:
       NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);

data/rice/detail/NativeAttributeSet.ipp

@@ -31,7 +31,7 @@ namespace Rice::detail
   }
 
   template<typename Attribute_T>
-  inline Resolved NativeAttributeSet<Attribute_T>::matches(int argc, const VALUE* argv, VALUE self)
+  inline Resolved NativeAttributeSet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
   {
     if (argc == 1)
       return Resolved{ Convertible::Exact, 1, this };
@@ -40,43 +40,31 @@ namespace Rice::detail
   }
 
   template<typename Attribute_T>
-  inline VALUE NativeAttributeSet<Attribute_T>::operator()(int argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeAttributeSet<Attribute_T>::operator()(size_t 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>))
+
+    if constexpr (!std::is_null_pointer_v<Receiver_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_);
+      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
     }
 
     return value;
   }
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeSet<Attribute_T>::toString()
+  {
+    return "";
+  }
 } // Rice

data/rice/detail/NativeCallbackFFI.ipp

@@ -1,4 +1,5 @@
 #ifdef HAVE_LIBFFI
+#include <tuple>
 #include <ffi.h>
 
 namespace Rice::detail
@@ -118,7 +119,7 @@ namespace Rice::detail
 
     // 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_);
+    ffi_prep_closure_loc(this->closure_, &cif_, ffiCallback, (void*)this, (void*)this->callback_);
   }
 
   template<typename Return_T, typename ...Arg_Ts>

data/rice/detail/NativeFunction.hpp

@@ -64,14 +64,25 @@ namespace Rice::detail
     void operator=(const NativeFunction_T&) = delete;
     void operator=(NativeFunction_T&&) = delete;
 
-    Resolved matches(int argc, const VALUE* argv, VALUE self) override;
-    VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
+    Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+    std::string toString() override;
 
     NativeFunction(Function_T function);
     NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+
   protected:
 
   private:
+    template<int I>
+    Convertible matchParameter(std::vector<std::optional<VALUE>>& value);
+
+    template<std::size_t...I>
+    Convertible matchParameters(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
+
+    template<std::size_t...I>
+    std::vector<std::string> argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices);
+
     template<typename T, std::size_t I>
     From_Ruby<T> createFromRuby();
       
@@ -83,14 +94,14 @@ namespace Rice::detail
     To_Ruby<To_Ruby_T> createToRuby();
       
     // Convert Ruby argv pointer to Ruby values
-    std::vector<VALUE> getRubyValues(int argc, const VALUE* argv, bool validate);
+    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
 
     template<typename Arg_T, int I>
-    Arg_T getNativeValue(std::vector<VALUE>& values);
+    Arg_T getNativeValue(std::vector<std::optional<VALUE>>& values);
 
     // Convert Ruby values to C++ values
     template<typename std::size_t...I>
-    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
+    Arg_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
 
     // Figure out what self is
     Receiver_T getReceiver(VALUE self);
@@ -99,7 +110,7 @@ namespace Rice::detail
     [[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<VALUE>& rubyValues);
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
 
     // Call the underlying C++ function
     VALUE invokeNativeFunction(Arg_Ts&& nativeArgs);

data/rice/detail/NativeFunction.ipp

@@ -1,8 +1,8 @@
-#include <array>
 #include <algorithm>
+#include <array>
 #include <stdexcept>
 #include <sstream>
-
+#include <tuple>
 
 namespace Rice::detail
 {
@@ -29,8 +29,11 @@ namespace Rice::detail
   template<typename Class_T, typename Function_T, bool IsMethod>
   VALUE NativeFunction<Class_T, Function_T, IsMethod>::procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
   {
-    NativeFunction_T* native = (NativeFunction_T*)callback_arg;
-    return (*native)(argc, argv, Qnil);
+    return cpp_protect([&]
+    {
+      NativeFunction_T * native = (NativeFunction_T*)callback_arg;
+      return (*native)(argc, argv, Qnil);
+    });
   }
 
   // Ruby calls this method if an instance f a NativeFunction is owned by a Ruby proc. That happens when C++
@@ -43,7 +46,6 @@ namespace Rice::detail
     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)
@@ -64,6 +66,43 @@ namespace Rice::detail
   {
   }
 
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  std::vector<std::string> NativeFunction<Class_T, Function_T, IsMethod>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
+  {
+    std::vector<std::string> typeNames;
+    (typeNames.push_back(cppClassName(typeName(typeid(typename std::tuple_element<I, Arg_Ts>::type)))), ...);
+    return typeNames;
+  }
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  std::string NativeFunction<Class_T, Function_T, IsMethod>::toString()
+  {
+    std::ostringstream result;
+
+    result << cppClassName(typeName(typeid(Return_T))) << " ";
+    
+    if (!std::is_null_pointer_v<Receiver_T>)
+    {
+      result << cppClassName(typeName(typeid(Receiver_T))) << "::";
+    }
+    
+    result << this->method_name_;
+
+    result << "(";
+
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    std::vector<std::string> argTypeNames = this->argTypeNames(result, indices);
+    for (size_t i = 0; i < argTypeNames.size(); i++)
+    {
+      result << argTypeNames[i];
+      if (i < argTypeNames.size() - 1)
+        result << ", ";
+    }
+    result << ")";
+    return result.str();
+  }
+    
   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()
   {
@@ -101,60 +140,100 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  Resolved NativeFunction<Class_T, Function_T, IsMethod>::matches(int argc, const VALUE* argv, VALUE self)
+  template<int I>
+  Convertible NativeFunction<Class_T, Function_T, IsMethod>::matchParameter(std::vector<std::optional<VALUE>>& values)
   {
-    // 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 };
-
+    Convertible result = Convertible::None;
     MethodInfo* methodInfo = this->methodInfo_.get();
-    int index = 0;
-
-    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv, false);
+    const Arg* arg = methodInfo->arg(I);
+    std::optional<VALUE> value = values[I];
 
-    // Loop over each FromRuby instance
-    for_each_tuple(this->fromRubys_,
-      [&](auto& fromRuby)
+    // Is a VALUE being passed directly to C++ ?
+    if (value.has_value())
+    {
+      if (arg->isValue())
       {
-        Convertible convertible = Convertible::None;
-
-        const Arg* arg = methodInfo->arg(index);
+        result = Convertible::Exact;
+      }
+      // If index is less than argc then check with FromRuby if the VALUE is convertible
+      // to C++.
+      else
+      {
+        VALUE value = values[I].value();
+        auto fromRuby = std::get<I>(this->fromRubys_);
+        result = fromRuby.is_convertible(value);
 
-        // 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())
+        // If this is an exact match check if the const-ness of the value and the parameter match
+        if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA)
         {
-          convertible = Convertible::Exact;
+          // Check the constness of the Ruby wrapped value and the parameter
+          WrapperBase* wrapper = getWrapper(value);
+          using Parameter_T = std::tuple_element_t<I, Arg_Ts>;
+
+          // Do not send a const value to a non-const parameter
+          if (wrapper->isConst() && !is_const_any_v<Parameter_T>)
+          {
+            result = Convertible::None;
+          }
+          // It is ok to send a non-const value to a const parameter but
+          // prefer non-const to non-const by slighly decreasing the convertible value
+          else if (!wrapper->isConst() && is_const_any_v<Parameter_T>)
+          {
+            result = Convertible::Const;
+          }
         }
+      }
+    }
+    // Last check if a default value has been set
+    else if (arg->hasDefaultValue())
+    {
+      result = Convertible::Exact;
+    }
+
+    return result;
+  }
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  Convertible NativeFunction<Class_T, Function_T, IsMethod>::matchParameters(std::vector<std::optional<VALUE>>& values,
+    std::index_sequence<I...>& indices)
+  {
+    Convertible result = Convertible::Exact;
+    ((result = result & this->matchParameter<I>(values)), ...);
+    return result;
+  }
 
-        result.convertible = result.convertible & convertible;
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  Resolved NativeFunction<Class_T, Function_T, IsMethod>::matches(size_t argc, const VALUE* argv, VALUE self)
+  {
+    // Return false if Ruby provided more arguments than the C++ method takes
+    if (argc > arity)
+      return Resolved{ Convertible::None, 0, this };
 
-        index++;
-      });
+    Resolved result { Convertible::Exact, 1, this };
+
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, false);
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    result.convertible = this->matchParameters(rubyValues, indices);
 
     if constexpr (arity > 0)
-      result.parameterMatch = rubyValues.size() / (double)arity;
+    {
+      int providedValues = std::count_if(rubyValues.begin(), rubyValues.end(), [](std::optional<VALUE>& value)
+        {
+          return value.has_value();
+        });
 
+      result.parameterMatch = providedValues / (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<std::optional<VALUE>> NativeFunction<Class_T, Function_T, IsMethod>::getRubyValues(size_t argc, const VALUE* argv, bool validate)
   {
-    std::vector<VALUE> result;
+#undef max
+    int size = std::max((size_t)arity, (size_t)argc);
+    std::vector<std::optional<VALUE>> result(size);
 
     // Keyword handling
     if (rb_keyword_given_p())
@@ -165,9 +244,7 @@ namespace Rice::detail
       VALUE value = argv[actualArgc];
       Hash keywords(value);
 
-      result.resize(actualArgc + keywords.size());
-
-      // Copy over leading arguments
+      // Copy over leading non-keyword arguments
       for (int i = 0; i < actualArgc; i++)
       {
         result[i] = argv[i];
@@ -187,20 +264,39 @@ namespace Rice::detail
     }
     else
     {
-      std::copy(argv, argv + argc, std::back_inserter(result));
+      std::copy(argv, argv + argc, result.begin());
     }
      
     // 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>)
+    if (rb_block_given_p() && result.size() > 0 && !result.back().has_value())
     {
       VALUE proc = rb_block_proc();
-      result.push_back(proc);
+      result.back() = proc;
     }
 
     if (validate)
     {
-      this->methodInfo_->verifyArgCount(result.size());
+      // Protect against user sending too many arguments
+      if (argc > arity)
+      {
+        std::string message = "wrong number of arguments (given " +
+          std::to_string(argc) + ", expected " + std::to_string(arity) + ")";
+        throw std::invalid_argument(message);
+      }
+
+      for (size_t i=0; i<result.size(); i++)
+      {
+        std::optional<VALUE> value = result[i];
+        Arg* arg = this->methodInfo_->arg(i);
+
+        if (!arg->hasDefaultValue() && !value.has_value())
+        {
+          std::string message;
+          message = "Missing argument. Name: " + arg->name + ". Index: " + std::to_string(arg->position) + ".";
+          throw std::invalid_argument(message);
+        }
+      }
     }
     
     return result;
@@ -208,7 +304,7 @@ namespace Rice::detail
 
   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)
+  Arg_T NativeFunction<Class_T, Function_T, IsMethod>::getNativeValue(std::vector<std::optional<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)
@@ -218,22 +314,31 @@ namespace Rice::detail
        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;
+    std::optional<VALUE> value = values[I];
+    Arg* arg = this->methodInfo_->arg(I);
 
     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);
+      return (Arg_T)std::get<I>(this->fromRubys_).convert(value.value());
     }
-    else
+    else if (value.has_value())
     {
-      return std::get<I>(this->fromRubys_).convert(value);
+      return std::get<I>(this->fromRubys_).convert(value.value());
     }
+    else if constexpr (std::is_constructible_v<std::remove_cv_t<Arg_T>, std::remove_cv_t<std::remove_reference_t<Arg_T>>&>)
+    {
+      if (arg->hasDefaultValue())
+      {
+        return arg->defaultValue<Arg_T>();
+      }
+    }
+
+    throw std::invalid_argument("Could not convert Rubyy value");
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
   template<std::size_t... I>
-  typename NativeFunction<Class_T, Function_T, IsMethod>::Arg_Ts NativeFunction<Class_T, Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
+  typename NativeFunction<Class_T, Function_T, IsMethod>::Arg_Ts NativeFunction<Class_T, Function_T, IsMethod>::getNativeValues(std::vector<std::optional<VALUE>>& values,
      std::index_sequence<I...>& indices)
   {
     /* Loop over each value returned from Ruby and convert it to the appropriate C++ type based
@@ -298,7 +403,7 @@ namespace Rice::detail
       Return_T nativeResult = std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
 
       // Return the result
-      return this->toRuby_.convert(nativeResult);
+      return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
     }
   }
 
@@ -343,7 +448,7 @@ namespace Rice::detail
         }
       }
 
-      return this->toRuby_.convert(nativeResult);
+      return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
     }
   }
 
@@ -364,7 +469,7 @@ 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)
+  void NativeFunction<Class_T, Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
   {
     // Self will be Qnil for wrapped procs
     if (self == Qnil)
@@ -372,7 +477,7 @@ namespace Rice::detail
 
     // 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);
+    WrapperBase* selfWrapper = getWrapper(self);
 
     // Check function arguments
     for (const Arg& arg : (*this->methodInfo_))
@@ -383,7 +488,7 @@ namespace Rice::detail
         {
           noWrapper(self, "self");
         }
-        selfWrapper->addKeepAlive(rubyValues[arg.position]);
+        selfWrapper->addKeepAlive(rubyValues[arg.position].value());
       }
     }
 
@@ -396,7 +501,7 @@ namespace Rice::detail
       }
 
       // returnWrapper will be nullptr if returnValue is a built-in type and not an external(wrapped) type
-      Wrapper* returnWrapper = getWrapper(returnValue);
+      WrapperBase* returnWrapper = getWrapper(returnValue);
       if (returnWrapper == nullptr)
       {
         noWrapper(returnValue, "return");
@@ -406,10 +511,10 @@ namespace Rice::detail
   }
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::operator()(int argc, const VALUE* argv, VALUE self)
+  VALUE NativeFunction<Class_T, Function_T, IsMethod>::operator()(size_t argc, const VALUE* argv, VALUE self)
   {
     // Get the ruby values and make sure we have the correct number
-    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv, true);
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, true);
 
     auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
 

data/rice/detail/NativeIterator.hpp

@@ -26,8 +26,9 @@ namespace Rice::detail
     void operator=(const NativeIterator_T&) = delete;
     void operator=(NativeIterator_T&&) = delete;
 
-    Resolved matches(int argc, const VALUE* argv, VALUE self) override;
-    VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
+    Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+    std::string toString() override;
 
   protected:
     NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);

data/rice/detail/NativeIterator.ipp

@@ -26,7 +26,7 @@ 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)
+  inline Resolved NativeIterator<T, Iterator_Func_T>::matches(size_t argc, const VALUE* argv, VALUE self)
   {
     return Resolved{ Convertible::Exact, 1.0, this };
   }
@@ -72,7 +72,7 @@ namespace Rice::detail
   }
 
   template<typename T, typename Iterator_Func_T>
-  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(int argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
   {
     if (!protect(rb_block_given_p))
     {
@@ -95,4 +95,10 @@ namespace Rice::detail
       return self;
     }
   }
+
+  template<typename T, typename Iterator_Func_T>
+  inline std::string NativeIterator<T, Iterator_Func_T>::toString()
+  {
+    return "";
+  }
 }

data/rice/detail/RubyFunction.ipp

@@ -1,5 +1,6 @@
 
 #include <any>
+#include <tuple>
 
 namespace Rice::detail
 {

data/rice/detail/RubyType.hpp

@@ -8,12 +8,9 @@ namespace Rice::detail
   template <typename T>
   class RubyType
   {
-  public:
-    static std::set<ruby_value_type> types();
-    static std::set<ruby_value_type> convertibleFrom();
-    static T(*converter)(VALUE);
-    static std::string packTemplate;
   };
+
+  void define_ruby_types();
 }
 
 #endif // Rice__detail__ruby__type__hpp_