rice 4.6.1 → 4.7.1

data/rice/detail/NativeAttributeSet.ipp

@@ -52,7 +52,16 @@ namespace Rice::detail
     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);
+
+      // Deal with pointers to pointes, see Parameter::convertToNative commment
+      if constexpr (is_pointer_pointer_v<Attr_T> && !std::is_convertible_v<remove_cv_recursive_t<Attr_T>, Attr_T>)
+      {
+        nativeSelf->*attribute_ = (Attr_T)From_Ruby<T_Unqualified>().convert(value);
+      }
+      else
+      {
+        nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+      }
     }
     else
     {
@@ -67,4 +76,23 @@ namespace Rice::detail
   {
     return "";
   }
-} // Rice
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeSet<Attribute_T>::name()
+  {
+    return this->name_;
+  }
+
+  template<typename Attribute_T>
+  inline NativeKind NativeAttributeSet<Attribute_T>::kind()
+  {
+    return NativeKind::AttributeWriter;
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeSet<Attribute_T>::returnKlass()
+  {
+    TypeMapper<Attr_T> typeMapper;
+    return typeMapper.rubyKlass();
+  }
+}

data/rice/detail/NativeCallbackFFI.ipp

@@ -64,7 +64,7 @@ namespace Rice::detail
        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. */
+       T** -> const T**, see comment in convertToNative method. */
     return std::forward_as_tuple(*(std::tuple_element_t<I, Tuple_T>*)(args[I])...);
   }
 
@@ -137,7 +137,7 @@ namespace Rice::detail
     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));
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(methodInfo_->returnInfo()));
       return fromRuby.convert(result);
     }
   }

data/rice/detail/NativeCallbackSimple.ipp

@@ -15,7 +15,7 @@ namespace Rice::detail
     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));
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(methodInfo_->returnInfo()));
       return fromRuby.convert(result);
     }
   }

data/rice/detail/NativeFunction.hpp

@@ -35,77 +35,40 @@ namespace Rice::detail
    *    calling them methods (self) or functions (no self).
    */
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<typename Function_T>
   class NativeFunction: Native
   {
   public:
-    using NativeFunction_T = NativeFunction<Class_T, Function_T, IsMethod>;
+    using NativeFunction_T = NativeFunction<Function_T>;
 
     // 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 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 Class_T = typename function_traits<Function_T>::class_type;
+    using Arg_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);
 
-    // 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;
-    NativeFunction(const NativeFunction_T&) = delete;
-    NativeFunction(NativeFunction_T&&) = delete;
-    void operator=(const NativeFunction_T&) = delete;
-    void operator=(NativeFunction_T&&) = delete;
+    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
-    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:
+    std::string name() override;
+    NativeKind kind() override;
+    VALUE returnKlass() override;
 
   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();
-      
-    // Create NativeArgs which are used to convert values from Ruby to C++
-    template<std::size_t...I>
-    From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
-
-    // Convert C++ value to Ruby
-    To_Ruby<To_Ruby_T> createToRuby();
-      
-    // Convert Ruby argv pointer to Ruby values
-    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<std::optional<VALUE>>& values);
-
     // 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);
 
-    // Figure out what self is
-    Receiver_T getReceiver(VALUE self);
-
     // Throw an exception when wrapper cannot be extracted
     [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
 
@@ -113,16 +76,15 @@ namespace Rice::detail
     void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
 
     // Call the underlying C++ function
-    VALUE invokeNativeFunction(Arg_Ts&& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs);
+    VALUE invoke(Arg_Ts&& nativeArgs);
+    VALUE invokeNoGVL(Arg_Ts&& nativeArgs);
 
   private:
     VALUE klass_;
     std::string method_name_;
     Function_T function_;
-    From_Ruby_Args_Ts fromRubys_;
-    To_Ruby<To_Ruby_T> toRuby_;
     std::unique_ptr<MethodInfo> methodInfo_;
+    To_Ruby<To_Ruby_T> toRuby_;
   };
 }