rice 4.7.1 → 4.8.0

data/rice/cpp_api/Hash.ipp

@@ -234,7 +234,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -244,7 +244,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -253,11 +253,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -273,5 +273,8 @@ namespace Rice::detail
     {
       return Hash(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Module.hpp

@@ -49,11 +49,11 @@ namespace Rice
 
     #include "shared_methods.hpp"
   protected:
-    template<typename Function_T>
-    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+    template<typename Function_T, typename ...Arg_Ts>
+    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args);
 
-    template<typename Class_T = VALUE, typename Method_T>
-    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo);
+    template<typename Class_T = VALUE, typename Method_T, typename ...Arg_Ts>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args);
   };
 
   //! Define a new module in the namespace given by module.

data/rice/cpp_api/Module.ipp

@@ -32,16 +32,18 @@ namespace Rice
     this->set_value(result);
   }
 
-  template<typename Function_T>
-  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
+  template<typename Function_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args)
   {
-    detail::NativeFunction<Function_T>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeFunction<Function_T, isNoGVL>::define(klass, name, std::forward<Function_T>(function), args...);
   }
 
-  template<typename Class_T, typename Method_T>
-  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  template<typename Class_T, typename Method_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args)
   {
-    detail::NativeMethod<Class_T, Method_T>::define(klass, name, std::forward<Method_T>(method), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeMethod<Class_T, Method_T, isNoGVL>::define(klass, name, std::forward<Method_T>(method), args...);
   }
 
   inline Module define_module_under(Object parent, char const* name)
@@ -94,7 +96,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -104,7 +106,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -114,7 +116,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -124,7 +126,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Object.hpp

@@ -181,8 +181,8 @@ namespace Rice
     *    float ret = x.call<float>("foo", z, 42);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    Object call(Identifier id, Parameter_Ts... args) const;
 
     //! Call the Ruby method specified by 'id' on object 'obj'.
     /*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
@@ -204,8 +204,8 @@ namespace Rice
     *    float ret = x.call_kw<float>("foo", kw);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call_kw(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    Object call_kw(Identifier id, Parameter_Ts... args) const;
 
     //! Vectorized call.
     /*! Calls the method identified by id with the list of arguments

data/rice/cpp_api/Object.ipp

@@ -27,8 +27,8 @@ namespace Rice
     return *this;
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  inline Object Object::call(Identifier id, Parameter_Ts... args) const
   {
     /* IMPORTANT - We store VALUEs in an array that is a local variable.
        That allows the Ruby garbage collector to find them when scanning
@@ -37,15 +37,15 @@ namespace Rice
        to the destination method resulting in a segmentation fault. This is
        easy to duplicate by setting GC.stress to true and calling a constructor
        that takes multiple values like a std::pair wrapper. */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(std::forward<Arg_Ts>(args))... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(std::forward<Parameter_Ts>(args))... };
     return detail::protect(rb_funcallv, value(), id.id(), (int)values.size(), (const VALUE*)values.data());
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call_kw(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  inline Object Object::call_kw(Identifier id, Parameter_Ts... args) const
   {
     /* IMPORTANT - See call() above */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(args)... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(args)... };
     return detail::protect(rb_funcallv_kw, value(), id.id(), (int)values.size(), (const VALUE*)values.data(), RB_PASS_KEYWORDS);
   }
 
@@ -202,7 +202,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -212,7 +212,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -221,7 +221,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -231,7 +231,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -240,11 +240,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -260,5 +260,8 @@ namespace Rice::detail
     {
       return Object(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/String.hpp

@@ -38,8 +38,8 @@ namespace Rice
     String(std::string_view const& s);
 
     //! Format a string using printf-style formatting.
-    template <typename... Arg_Ts>
-    static inline String format(char const* fmt, Arg_Ts&&...args);
+    template <typename... Parameter_Ts>
+    static inline String format(char const* fmt, Parameter_Ts&&...args);
 
     //! Get the length of the String.
     /*! \return the length of the string.

data/rice/cpp_api/String.ipp

@@ -28,16 +28,16 @@ namespace Rice
   {
   }
 
-  template <typename... Arg_Ts>
-  inline String String::format(char const* fmt, Arg_Ts&&...args)
+  template <typename... Parameter_Ts>
+  inline String String::format(char const* fmt, Parameter_Ts&&...args)
   {
-    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
+    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Parameter_Ts>(args)...);
     std::string temp(size, '\0');
 
     // size+1 avoids truncating the string. Otherwise snprintf writes n - 1 characters
     // to allow space for null character but we don't need that since std::string
     // will add a null character internally at n + 1
-    std::snprintf(&temp[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+    std::snprintf(&temp[0], size + 1, fmt, std::forward<Parameter_Ts>(args)...);
 
     String s = String(temp.c_str());
     return s;
@@ -97,7 +97,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -107,7 +107,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -116,11 +116,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -136,5 +136,8 @@ namespace Rice::detail
     {
       return String(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Symbol.ipp

@@ -67,7 +67,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -77,7 +77,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -87,7 +87,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -97,7 +97,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -110,15 +110,15 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_SYMBOL:
           return Convertible::Exact;
           break;
-      case RUBY_T_STRING:
-          return Convertible::Cast;
+        case RUBY_T_STRING:
+          return Convertible::Exact;
           break;
         default:
           return Convertible::None;

data/rice/cpp_api/shared_methods.hpp

@@ -33,8 +33,7 @@ inline auto& include_module(Module const& inc)
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -52,8 +51,7 @@ inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -75,8 +73,7 @@ inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&.
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_singleton_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -94,8 +91,7 @@ inline auto& define_singleton_method(std::string name, Method_T&& method, const
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_singleton_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -112,7 +108,7 @@ inline auto& define_singleton_function(std::string name, Function_T&& func, cons
  *  \return *this
  */
 template<typename Function_T, typename...Arg_Ts>
-inline auto& define_module_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
+inline auto& define_module_function(std::string name, Function_T&& func, Arg_Ts&& ...args)
 {
   if (this->rb_type() != T_MODULE)
   {

data/rice/detail/InstanceRegistry.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__InstanceRegistry__hpp_
 #define Rice__detail__InstanceRegistry__hpp_
 
-#include <map>
-
 namespace Rice::detail
 {
   class InstanceRegistry

data/rice/detail/Native.hpp

@@ -11,8 +11,7 @@ namespace Rice::detail
     inline bool operator<(Resolved other);
     inline bool operator>(Resolved other);
 
-    Convertible convertible;
-    double parameterMatch;
+    double score;  // Combined score: minParameterScore * parameterMatch
     Native* native;
   };
 
@@ -23,7 +22,8 @@ namespace Rice::detail
     Iterator,
     AttributeReader,
     AttributeWriter,
-    Proc
+    Proc,
+    Callback
   };
 
   class Native
@@ -31,8 +31,9 @@ namespace Rice::detail
   public:
     static VALUE resolve(int argc, VALUE* argv, VALUE self);
   public:
-    Native() = default;
-    Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
+    Native(std::string name);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
     virtual ~Native() = default;
 
     Native(const Native&) = delete;
@@ -40,36 +41,45 @@ namespace Rice::detail
     void operator=(const Native&) = delete;
     void operator=(Native&&) = delete;
 
-    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self);
-    virtual VALUE operator()(size_t argc, const VALUE* argv, VALUE self) = 0;
+    virtual Resolved matches(std::map<std::string, VALUE>& values);
+    virtual VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) = 0;
     virtual std::string toString() = 0;
 
     // Ruby API access
-    virtual std::string name() = 0;
+    std::string name();
+    std::vector<const ParameterAbstract*> parameters();
     virtual NativeKind kind() = 0;
     virtual VALUE returnKlass() = 0;
-    std::vector<const ParameterAbstract*> parameters();
 
   protected:
-    template<typename T>
-    static void verify_type(bool isBuffer);
+    template<typename T, bool isBuffer>
+    static void verify_type();
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static void verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
-
-    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
+    static std::map<std::string, VALUE> readRubyArgs(size_t argc, const VALUE* argv);
+    std::vector<std::optional<VALUE>> getRubyValues(std::map<std::string, VALUE> values, bool validate);
     ParameterAbstract* getParameterByName(std::string name);
-    Convertible matchParameters(std::vector<std::optional<VALUE>>& values);
+    double matchParameters(std::vector<std::optional<VALUE>>& values, size_t argc);
+
+    template<typename Parameter_Tuple, typename... Arg_Ts>
+    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(Arg_Ts&& ...args);
 
-    template<typename Tuple_T>
-    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(MethodInfo* methodInfo);
+    template<typename... Arg_Ts>
+    static std::unique_ptr<Return> create_return(Arg_Ts& ...args);
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
+
+  private:
+    template<typename Parameter_Tuple, typename Arg_Tuple, std::size_t ...Indices>
+    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, std::index_sequence<Indices...> indices, std::vector<std::unique_ptr<Arg>>&& args);
+
+    template<typename Parameter_Tuple, typename Arg_Tuple, size_t I>
+    static void verify_parameter();
 
   protected:
+    std::string name_;
+    std::unique_ptr<Return> returnInfo_;
     std::vector<std::unique_ptr<ParameterAbstract>> parameters_;
-
   };
 }