rice 4.7.1 → 4.8.0

data/rice/detail/NativeFunction.ipp

@@ -6,13 +6,14 @@
 
 namespace Rice::detail
 {
-  template<typename Function_T>
-  void NativeFunction<Function_T>::define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
+  template<typename Function_T, bool NoGVL>
+  template<typename ...Arg_Ts>
+  void NativeFunction<Function_T, NoGVL>::define(VALUE klass, std::string method_name, Function_T function, Arg_Ts&& ...args)
   {
-    // Verify return and argument types
-    Native::verify_type<Return_T>(methodInfo->returnInfo()->isBuffer());
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    Native::verify_args<Arg_Ts>(methodInfo, indices);
+    // Verify return type
+    using Arg_Tuple = std::tuple<Arg_Ts...>;
+    constexpr bool isBuffer = tuple_element_index_v<Arg_Tuple, ReturnBuffer> < std::tuple_size_v<Arg_Tuple>;
+    Native::verify_type<Return_T, isBuffer>();
 
     // Have we defined this method yet in Ruby?
     Identifier identifier(method_name);
@@ -23,24 +24,29 @@ namespace Rice::detail
       detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
     }
 
-    // Create a NativeFunction instance and save it to the NativeRegistry. There may be multiple
-    // NativeFunction instances for a specific method because C++ supports method overloading.
-    NativeFunction_T* nativeFunction = new NativeFunction_T(klass, method_name, std::forward<Function_T>(function), methodInfo);
+    // Create function parameters - this will also validate their types
+    std::vector<std::unique_ptr<ParameterAbstract>> parameters = Native::create_parameters<Parameter_Ts>(args...);
+
+    // Create return info
+    std::unique_ptr<Return> returnInfo = Native::create_return<Arg_Ts...>(args...);
+
+    // Create native method
+    NativeFunction_T* nativeFunction = new NativeFunction_T(klass, method_name, std::forward<Function_T>(function), std::move(returnInfo), std::move(parameters));
     std::unique_ptr<Native> native(nativeFunction);
+
+    // Register the native function
     detail::Registries::instance.natives.add(klass, identifier.id(), native);
   }
 
-  template<typename Function_T>
-  NativeFunction<Function_T>::NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
-    : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
-      klass_(klass), method_name_(method_name), function_(function), methodInfo_(methodInfo),
-      toRuby_(methodInfo->returnInfo())
+  template<typename Function_T, bool NoGVL>
+  NativeFunction<Function_T, NoGVL>::NativeFunction(VALUE klass, std::string function_name, Function_T function, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters)
+    : Native(function_name, std::move(returnInfo), std::move(parameters)),
+      klass_(klass), function_(function), toRuby_(returnInfo_.get())
   {
   }
 
-  template<typename Function_T>
-  template<std::size_t... I>
-  std::vector<std::string> NativeFunction<Function_T>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
+  template<typename Function_T, bool NoGVL>
+  std::vector<std::string> NativeFunction<Function_T, NoGVL>::argTypeNames()
   {
     std::vector<std::string> result;
     for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
@@ -50,19 +56,18 @@ namespace Rice::detail
     return result;
   }
 
-  template<typename Function_T>
-  std::string NativeFunction<Function_T>::toString()
+  template<typename Function_T, bool NoGVL>
+  std::string NativeFunction<Function_T, NoGVL>::toString()
   {
     std::ostringstream result;
 
-    detail::TypeMapper<Return_T> typeMapper;
-    result << typeMapper.simplifiedName() << " ";
-    result << this->method_name_;
+    detail::TypeIndexParser typeIndexParser(typeid(Return_T), std::is_fundamental_v<detail::intrinsic_type<Return_T>>);
+    result << typeIndexParser.simplifiedName() << " ";
+    result << this->name();
 
     result << "(";
 
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    std::vector<std::string> argTypeNames = this->argTypeNames(result, indices);
+    std::vector<std::string> argTypeNames = this->argTypeNames();
     for (size_t i = 0; i < argTypeNames.size(); i++)
     {
       result << argTypeNames[i];
@@ -73,138 +78,78 @@ namespace Rice::detail
     return result.str();
   }
     
-  template<typename Function_T>
+  template<typename Function_T, bool NoGVL>
   template<std::size_t... I>
-  typename NativeFunction<Function_T>::Arg_Ts NativeFunction<Function_T>::getNativeValues(std::vector<std::optional<VALUE>>& values,
-     std::index_sequence<I...>& indices)
+  typename NativeFunction<Function_T, NoGVL>::Parameter_Ts NativeFunction<Function_T, NoGVL>::getNativeValues(std::vector<std::optional<VALUE>>& values,
+     std::index_sequence<I...>&)
   {
     /* 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
+       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(this->getNativeValue<std::tuple_element_t<I, Arg_Ts>, I>(values)...);
+    //return std::forward_as_tuple(this->getNativeValue<std::tuple_element_t<I, Parameter_Ts>, I>(values)...);
     return std::forward_as_tuple(
-      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Parameter_Ts>>*>(this->parameters_[I].get()))->
                convertToNative(values[I])...);
   }
 
-  template<typename Function_T>
-  VALUE NativeFunction<Function_T>::invoke(Arg_Ts&& nativeArgs)
+  template<typename Function_T, bool NoGVL>
+  VALUE NativeFunction<Function_T, NoGVL>::invoke(Parameter_Ts&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
+      std::apply(this->function_, std::forward<Parameter_Ts>(nativeArgs));
       return Qnil;
     }
     else
     {
       // Call the native method and get the result
-      Return_T nativeResult = std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
+      Return_T nativeResult = std::apply(this->function_, std::forward<Parameter_Ts>(nativeArgs));
 
       // Return the result
       return this->toRuby_.convert(nativeResult);
     }
   }
 
-  template<typename Function_T>
-  VALUE NativeFunction<Function_T>::invokeNoGVL(Arg_Ts&& nativeArgs)
+  template<typename Function_T, bool NoGVL>
+  VALUE NativeFunction<Function_T, NoGVL>::invokeNoGVL(Parameter_Ts&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
-      no_gvl(this->function_, std::forward<Arg_Ts>(nativeArgs));
+      no_gvl(this->function_, std::forward<Parameter_Ts>(nativeArgs));
       return Qnil;
     }
     else
     {
       // Call the native method and get the result
-      Return_T nativeResult = no_gvl(this->function_, std::forward<Arg_Ts>(nativeArgs));
+      Return_T nativeResult = no_gvl(this->function_, std::forward<Parameter_Ts>(nativeArgs));
 
       // Return the result
       return this->toRuby_.convert(nativeResult);
     }
   }
 
-  template<typename Function_T>
-  void NativeFunction<Function_T>::noWrapper(const VALUE klass, const std::string& wrapper)
-  {
-    std::stringstream message;
-
-    message << "When calling the method `";
-    message << this->method_name_;
-    message << "' we could not find the wrapper for the '";
-    message << rb_obj_classname(klass);
-    message << "' ";
-    message << wrapper;
-    message << " type. You should not use keepAlive() on a Return or Arg that is a builtin Rice type.";
-
-    throw std::runtime_error(message.str());
-  }
-
-  template<typename Function_T>
-  void NativeFunction<Function_T>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
-  {
-    // Self will be Qnil for wrapped procs
-    if (self == Qnil)
-      return;
-
-    // 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
-    WrapperBase* selfWrapper = getWrapper(self);
-
-    // Check function arguments
-    for (const Arg& arg : (*this->methodInfo_))
-    {
-      if (arg.isKeepAlive())
-      {
-        if (selfWrapper == nullptr)
-        {
-          noWrapper(self, "self");
-        }
-        selfWrapper->addKeepAlive(rubyValues[arg.position].value());
-      }
-    }
-
-    // Check return value
-    if (this->methodInfo_->returnInfo()->isKeepAlive())
-    {
-      if (selfWrapper == nullptr)
-      {
-        noWrapper(self, "self");
-      }
-
-      // returnWrapper will be nullptr if returnValue is a built-in type and not an external(wrapped) type
-      WrapperBase* returnWrapper = getWrapper(returnValue);
-      if (returnWrapper == nullptr)
-      {
-        noWrapper(returnValue, "return");
-      }
-      returnWrapper->addKeepAlive(self);
-    }
-  }
-
-  template<typename Function_T>
-  VALUE NativeFunction<Function_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  template<typename Function_T, bool NoGVL>
+  VALUE NativeFunction<Function_T, NoGVL>::operator()(std::map<std::string, VALUE>& values, VALUE self)
   {
     // Get the ruby values and make sure we have the correct number
-    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, true);
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(values, true);
 
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    auto indices = std::make_index_sequence<std::tuple_size_v<Parameter_Ts>>{};
 
     // Convert the Ruby values to native values
-    Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
-
-    bool noGvl = this->methodInfo_->function()->isNoGvl();
+    Parameter_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
     VALUE result = Qnil;
 
-    if (noGvl)
+    if constexpr (NoGVL)
     {
-      result = this->invokeNoGVL(std::forward<Arg_Ts>(nativeValues));
+      result = this->invokeNoGVL(std::forward<Parameter_Ts>(nativeValues));
     }
     else
     {
-      result = this->invoke(std::forward<Arg_Ts>(nativeValues));
+      result = this->invoke(std::forward<Parameter_Ts>(nativeValues));
     }
 
     // Check if any function arguments or return values need to have their lifetimes tied to the receiver
@@ -213,25 +158,19 @@ namespace Rice::detail
     return result;
   }
 
-  template<typename Function_T>
-  inline std::string NativeFunction<Function_T>::name()
-  {
-    return this->method_name_;
-  }
-
-  template<typename Function_T>
-  inline NativeKind NativeFunction<Function_T>::kind()
+  template<typename Function_T, bool NoGVL>
+  inline NativeKind NativeFunction<Function_T, NoGVL>::kind()
   {
     return NativeKind::Function;
   }
-
-  template<typename Function_T>
-  inline VALUE NativeFunction<Function_T>::returnKlass()
+  template<typename Function_T, bool NoGVL>
+  inline VALUE NativeFunction<Function_T, NoGVL>::returnKlass()
   {
     // Check if an array is being returned
-    if (this->methodInfo_->returnInfo()->isBuffer())
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
     {
-      TypeMapper<Pointer<Return_T>> typeMapper;
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Return_T>>>> typeMapper;
       return typeMapper.rubyKlass();
     }
     else

data/rice/detail/NativeInvoker.hpp

@@ -61,11 +61,11 @@ namespace Rice::detail
     ResultWrapper<Return_T> resultWrapper;
   };
 
-  template<typename Function_T, typename ...Arg_Ts>
-  auto protect(Function_T func, Arg_Ts...args);
+  template<typename Function_T, typename ...Parameter_Ts>
+  auto protect(Function_T func, Parameter_Ts...args);
 
-  template<typename Function_T, typename ...Arg_Ts>
-  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Arg_Ts...args);
+  template<typename Function_T, typename ...Parameter_Ts>
+  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Parameter_Ts...args);
 
   template<typename Function_T, typename Tuple_T>
   typename function_traits<Function_T>::return_type no_gvl(Function_T func, Tuple_T&& args);

data/rice/detail/NativeInvoker.ipp

@@ -8,7 +8,7 @@ namespace Rice::detail
     {
       return std::move(this->result_.value());
     }
-    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> return true. Sigh.
+    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
     else if constexpr (detail::is_std_vector_v<Return_T> && std::is_copy_constructible_v<Return_T>)
     {
       if constexpr (!std::is_copy_constructible_v<typename Return_T::value_type>)
@@ -112,11 +112,11 @@ namespace Rice::detail
 
   // ------- Helper Methods --------
   // Create a functor for calling a Ruby function and define some aliases for readability.
-  template<typename Function_T, typename ...Arg_Ts>
-  auto protect(Function_T func, Arg_Ts...args)
+  template<typename Function_T, typename ...Parameter_Ts>
+  auto protect(Function_T func, Parameter_Ts...args)
   {
     using Return_T = typename function_traits<Function_T>::return_type;
-    using Tuple_T = std::tuple<Arg_Ts...>;
+    using Tuple_T = std::tuple<Parameter_Ts...>;
     using Invoker_T = NativeInvoker<Return_T, Function_T, Tuple_T>;
 
     Tuple_T argsTuple = std::forward_as_tuple(args...);
@@ -157,10 +157,10 @@ namespace Rice::detail
     }
   }
 
-  template<typename Function_T, typename ...Arg_Ts>
-  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Arg_Ts...args)
+  template<typename Function_T, typename ...Parameter_Ts>
+  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Parameter_Ts...args)
   {
-    using Tuple_T = std::tuple<Arg_Ts...>;
+    using Tuple_T = std::tuple<Parameter_Ts...>;
     Tuple_T argsTuple = std::forward_as_tuple(args...);
     return no_gvl(func, argsTuple);
   }

data/rice/detail/NativeIterator.hpp

@@ -26,11 +26,10 @@ namespace Rice::detail
     void operator=(const NativeIterator_T&) = delete;
     void operator=(NativeIterator_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;
 
@@ -42,7 +41,6 @@ namespace Rice::detail
 
   private:
     VALUE klass_;
-    std::string method_name_;
     Iterator_Func_T begin_;
     Iterator_Func_T end_;
   };

data/rice/detail/NativeIterator.ipp

@@ -21,20 +21,20 @@ namespace Rice::detail
 
   template <typename T, typename Iterator_Func_T>
   inline NativeIterator<T, Iterator_Func_T>::NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end) :
-    klass_(klass), method_name_(method_name), begin_(begin), end_(end)
+    Native(method_name), klass_(klass), begin_(begin), end_(end)
   {
   }
 
   template<typename T, typename Iterator_Func_T>
-  inline Resolved NativeIterator<T, Iterator_Func_T>::matches(size_t argc, const VALUE* argv, VALUE self)
+  inline Resolved NativeIterator<T, Iterator_Func_T>::matches(std::map<std::string, VALUE>&)
   {
-    return Resolved{ Convertible::Exact, 1.0, this };
+    return Resolved{ Convertible::Exact, this };
   }
 
   template<typename T, typename Iterator_Func_T>
   inline VALUE NativeIterator<T, Iterator_Func_T>::createRubyEnumerator(VALUE self)
   {
-    auto rb_size_function = [](VALUE recv, VALUE argv, VALUE eobj) -> VALUE
+    auto rb_size_function = [](VALUE recv, VALUE, VALUE eobj) -> VALUE
     {
       // Since we can't capture VALUE self from above (because then we can't send
       // this lambda to rb_enumeratorize_with_size), extract it from recv
@@ -61,7 +61,7 @@ namespace Rice::detail
       });
     };
 
-    Identifier identifier(this->method_name_);
+    Identifier identifier(this->name());
     VALUE enumerator = protect(rb_enumeratorize_with_size, self, identifier.to_sym(), 0, nullptr, rb_size_function);
     
     // Hack the enumerator object by storing name_ on the enumerator object so
@@ -72,7 +72,7 @@ namespace Rice::detail
   }
 
   template<typename T, typename Iterator_Func_T>
-  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(std::map<std::string, VALUE>&, VALUE self)
   {
     if (!protect(rb_block_given_p))
     {
@@ -102,12 +102,6 @@ namespace Rice::detail
     return "";
   }
 
-  template<typename T, typename Iterator_Func_T>
-  inline std::string NativeIterator<T, Iterator_Func_T>::name()
-  {
-    return this->method_name_;
-  }
-
   template<typename T, typename Iterator_Func_T>
   inline NativeKind NativeIterator<T, Iterator_Func_T>::kind()
   {
@@ -117,7 +111,17 @@ namespace Rice::detail
   template<typename T, typename Iterator_Func_T>
   inline VALUE NativeIterator<T, Iterator_Func_T>::returnKlass()
   {
-    TypeMapper<Value_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<Value_T>>>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Value_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   }
 }

data/rice/detail/NativeMethod.hpp

@@ -35,61 +35,51 @@ namespace Rice::detail
    *    calling them methods (self) or functions (no self).
    */
 
-  template<typename Class_T, typename Method_T>
+  template<typename Class_T, typename Method_T, bool NoGVL>
   class NativeMethod: Native
   {
   public:
-    using NativeMethod_T = NativeMethod<Class_T, Method_T>;
+    using NativeMethod_T = NativeMethod<Class_T, Method_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 method_traits<Method_T>::Return_T;
     using Receiver_T = typename method_traits<Method_T>::Class_T;
-    using Arg_Ts = typename method_traits<Method_T>::Arg_Ts;
-    using Apply_Args_T = typename tuple_unshift<Receiver_T, Arg_Ts>::type;
+    using Parameter_Ts = typename method_traits<Method_T>::Parameter_Ts;
+    using Apply_Args_T = typename tuple_unshift<Receiver_T, Parameter_Ts>::type;
 
     using To_Ruby_T = remove_cv_recursive_t<Return_T>;
 
     // Register method with Ruby
-    static void define(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo);
+    template <typename ...Arg_Ts>
+    static void define(VALUE klass, std::string method_name, Method_T method, Arg_Ts&& ...args);
 
   public:
-    NativeMethod(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo);
+    NativeMethod(VALUE klass, std::string method_name, Method_T method, 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>
-    Apply_Args_T getNativeValues(VALUE self, std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
+    Apply_Args_T getNativeValues(VALUE self, std::vector<std::optional<VALUE>>& values, const 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);
-
-    // Do we need to keep alive any arguments?
-    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
-
     // Call the underlying C++ method
     VALUE invoke(VALUE self, Apply_Args_T&& nativeArgs);
     VALUE invokeNoGVL(VALUE self, Apply_Args_T&& nativeArgs);
 
   private:
     VALUE klass_;
-    std::string method_name_;
     Method_T method_;
-    std::unique_ptr<MethodInfo> methodInfo_;
     To_Ruby<To_Ruby_T> toRuby_;
   };
 }