rice 4.6.1 → 4.7.0

data/rice/detail/NativeMethod.ipp

@@ -0,0 +1,332 @@
+#include <algorithm>
+#include <array>
+#include <stdexcept>
+#include <sstream>
+#include <tuple>
+
+namespace Rice::detail
+{
+  template<typename Class_T, typename Method_T>
+  void NativeMethod<Class_T, Method_T>::define(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo)
+  {
+    // 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);
+
+    // Have we defined this method yet in Ruby?
+    Identifier identifier(method_name);
+    const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, identifier.id());
+    if (natives.empty())
+    {
+      // Tell Ruby to invoke the static resolved method defined above
+      detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+    }
+
+    // Create a NativeMethod instance and save it to the NativeRegistry. There may be multiple
+    // NativeMethod instances for a specific method because C++ supports method overloading.
+    NativeMethod_T* NativeMethod = new NativeMethod_T(klass, method_name, std::forward<Method_T>(method), methodInfo);
+    std::unique_ptr<Native> native(NativeMethod);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+  }
+
+  template<typename Class_T, typename Method_T>
+  NativeMethod<Class_T, Method_T>::NativeMethod(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo)
+    : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
+      klass_(klass), method_name_(method_name), method_(method), methodInfo_(methodInfo),
+      toRuby_(methodInfo->returnInfo())
+  {
+  }
+
+  template<typename Class_T, typename Method_T>
+  template<std::size_t... I>
+  std::vector<std::string> NativeMethod<Class_T, Method_T>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
+  {
+    std::vector<std::string> result;
+    for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
+    {
+      result.push_back(parameter->cppTypeName());
+    }
+    return result;
+  }
+
+  template<typename Class_T, typename Method_T>
+  std::string NativeMethod<Class_T, Method_T>::toString()
+  {
+    std::ostringstream result;
+
+    detail::TypeMapper<Return_T> typeReturnMapper;
+    result << typeReturnMapper.simplifiedName() << " ";
+    
+    if (!std::is_null_pointer_v<Receiver_T>)
+    {
+      detail::TypeMapper<Receiver_T> typeReceiverMapper;
+      result << typeReceiverMapper.simplifiedName() << "::";
+    }
+    
+    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 Method_T>
+  template<std::size_t... I>
+  typename NativeMethod<Class_T, Method_T>::Apply_Args_T NativeMethod<Class_T, Method_T>::getNativeValues(VALUE self, 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
+       on the arguments (Arg_Ts) required by the C++ method. 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->getReceiver(self),
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+               convertToNative(values[I])...);
+  }
+
+  template<typename Class_T, typename Method_T>
+  typename NativeMethod<Class_T, Method_T>::Receiver_T NativeMethod<Class_T, Method_T>::getReceiver(VALUE self)
+  {
+    // Self parameter is a Ruby VALUE so no conversion is needed
+    if constexpr (std::is_same_v<Receiver_T, VALUE>)
+    {
+      return self;
+    }
+    /* This case happens when a class wrapped by Rice is calling a method
+       defined on an ancestor class. For example, the std::map size method
+       is defined on _Tree not map. Rice needs to know the actual type
+       that was wrapped so it can correctly extract the C++ object from 
+       the Ruby object. */
+    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> && 
+                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_pointer_v<Receiver_T>)
+    {
+      Class_T* instance = From_Ruby<Class_T*>().convert(self);
+      return dynamic_cast<Receiver_T>(instance);
+    }
+    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
+                        std::is_reference_v<Receiver_T>)
+    {
+      Class_T& instance = From_Ruby<Class_T&>().convert(self);
+      return dynamic_cast<Receiver_T>(instance);
+    }
+    // Self parameter could be derived from Object or it is an C++ instance and
+    // needs to be unwrapped from Ruby
+    else
+    {
+      return From_Ruby<Receiver_T>().convert(self);
+    }
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline VALUE NativeMethod<Class_T, Method_T>::invoke(VALUE self, Apply_Args_T&& nativeArgs)
+  {
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->method_, std::forward<Apply_Args_T>(nativeArgs));
+      return Qnil;
+    }
+    else
+    {
+      Return_T nativeResult = std::apply(this->method_, std::forward<Apply_Args_T>(nativeArgs));
+
+      // Special handling if the method returns self. If so we do not want
+      // to create a new Ruby wrapper object and instead return self.
+      if constexpr (std::is_same_v<intrinsic_type<Return_T>, intrinsic_type<Receiver_T>>)
+      {
+				Receiver_T receiver = std::get<0>(nativeArgs);
+
+        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Receiver_T>)
+        {
+          if (nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Receiver_T>)
+        {
+          if (nativeResult == &receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Receiver_T>)
+        {
+          if (&nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Receiver_T>)
+        {
+          if (&nativeResult == &receiver)
+            return self;
+        }
+      }
+
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline VALUE NativeMethod<Class_T, Method_T>::invokeNoGVL(VALUE self, Apply_Args_T&& nativeArgs)
+  {
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      no_gvl(this->method_, std::forward<Apply_Args_T>(nativeArgs));
+      return Qnil;
+    }
+    else
+    {
+      Return_T nativeResult = no_gvl(this->method_, std::forward<Apply_Args_T>(nativeArgs));
+
+      // Special handling if the method returns self. If so we do not want
+      // to create a new Ruby wrapper object and instead return self.
+      if constexpr (std::is_same_v<intrinsic_type<Return_T>, intrinsic_type<Receiver_T>>)
+      {
+        Receiver_T receiver = std::get<0>(nativeArgs);
+
+        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Receiver_T>)
+        {
+          if (nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Receiver_T>)
+        {
+          if (nativeResult == &receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Receiver_T>)
+        {
+          if (&nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Receiver_T>)
+        {
+          if (&nativeResult == &receiver)
+            return self;
+        }
+      }
+
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline void NativeMethod<Class_T, Method_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 Class_T, typename Method_T>
+  void NativeMethod<Class_T, Method_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 method 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 Class_T, typename Method_T>
+  VALUE NativeMethod<Class_T, Method_T>::operator()(size_t argc, const VALUE* argv, 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);
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    Apply_Args_T nativeArgs = this->getNativeValues(self, rubyValues, indices);
+
+    bool noGvl = this->methodInfo_->function()->isNoGvl();
+
+    VALUE result = Qnil;
+
+    if (noGvl)
+    {
+      result = this->invokeNoGVL(self, std::forward<Apply_Args_T>(nativeArgs));
+    }
+    else
+    {
+      result = this->invoke(self, std::forward<Apply_Args_T>(nativeArgs));
+    }
+
+    // Check if any method arguments or return values need to have their lifetimes tied to the receiver
+    this->checkKeepAlive(self, result, rubyValues);
+
+    return result;
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline std::string NativeMethod<Class_T, Method_T>::name()
+  {
+    return this->method_name_;
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline NativeKind NativeMethod<Class_T, Method_T>::kind()
+  {
+    return NativeKind::Method;
+  }
+
+  template<typename Class_T, typename Method_T>
+  inline VALUE NativeMethod<Class_T, Method_T>::returnKlass()
+  {
+    // Check if an array is being returned
+    if (this->methodInfo_->returnInfo()->isBuffer())
+    {
+      TypeMapper<Pointer<Return_T>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Return_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+  }
+}

data/rice/detail/NativeProc.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__detail__Native_Proc__hpp_
+#define Rice__detail__Native_Proc__hpp_
+
+namespace Rice::detail
+{
+  template<typename Proc_T>
+  class NativeProc: Native
+  {
+  public:
+    using NativeProc_T = NativeProc<Proc_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<Proc_T>::return_type;
+    using Arg_Ts = typename function_traits<Proc_T>::arg_types;
+    using To_Ruby_T = remove_cv_recursive_t<Return_T>;
+
+    // Define a new Ruby Proc to wrap a C++ function
+    static VALUE createRubyProc(Proc_T proc);
+    static NativeProc<Proc_T>* define(Proc_T proc);
+
+    // This is the method Ruby calls when invoking the proc
+    static VALUE resolve(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+ 
+  public:
+    NativeProc(Proc_T proc, MethodInfo* methodInfo);
+    VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+    std::string toString() override;
+    
+    std::string name() override;
+    NativeKind kind() override;
+    VALUE returnKlass() override;
+
+  private:
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+
+    // 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);
+
+    // Call the underlying C++ function
+    VALUE invoke(Arg_Ts&& nativeArgs);
+
+  private:
+    Proc_T proc_;
+    std::unique_ptr<MethodInfo> methodInfo_;
+    To_Ruby<To_Ruby_T> toRuby_;
+  };
+}
+
+#endif // Rice__detail__Native_Proc__hpp_

data/rice/detail/NativeProc.ipp

@@ -0,0 +1,133 @@
+#include <algorithm>
+#include <array>
+#include <stdexcept>
+#include <sstream>
+#include <tuple>
+
+namespace Rice::detail
+{
+  template<typename Proc_T>
+  NativeProc<Proc_T>* NativeProc<Proc_T>::define(Proc_T proc)
+  {
+    MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Proc_T>::arity);
+    return new NativeProc_T(std::forward<Proc_T>(proc), methodInfo);
+  }
+
+  template<typename Proc_T>
+  VALUE NativeProc<Proc_T>::createRubyProc(Proc_T proc)
+  {
+    NativeProc_T* nativeProc = NativeProc_T::define(std::forward<Proc_T>(proc));
+
+    // Create a Ruby proc to wrap it and pass the NativeProc as a callback parameter
+    VALUE result = rb_proc_new(NativeProc_T::resolve, (VALUE)nativeProc);
+
+    // Tie the lifetime of the NativeProc to the Ruby Proc
+    VALUE finalizer = rb_proc_new(NativeProc_T::finalizerCallback, (VALUE)nativeProc);
+    rb_define_finalizer(result, finalizer);
+
+    return result;
+  }
+
+  // Ruby calls this method when invoking a proc that was defined as a C++ function
+  template<typename Proc_T>
+  VALUE NativeProc<Proc_T>::resolve(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  {
+    return cpp_protect([&]
+    {
+      NativeProc_T * native = (NativeProc_T*)callback_arg;
+      return (*native)(argc, argv, Qnil);
+    });
+  }
+
+  // Ruby calls this method if an instance of a NativeProc is owned by a Ruby proc. That happens when C++
+  // returns a function back to Ruby
+  template<typename Proc_T>
+  VALUE NativeProc<Proc_T>::finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  {
+    NativeProc_T* native = (NativeProc_T*)callback_arg;
+    delete native;
+    return Qnil;
+  }
+
+  template<typename Proc_T>
+  NativeProc<Proc_T>::NativeProc(Proc_T proc, MethodInfo* methodInfo) : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
+                                                                        proc_(proc), methodInfo_(methodInfo)
+  {
+  }
+
+  template<typename Proc_T>
+  std::string NativeProc<Proc_T>::toString()
+  {
+    return "Proc";
+  }
+
+  template<typename Proc_T>
+  template<std::size_t... I>
+  typename NativeProc<Proc_T>::Arg_Ts NativeProc<Proc_T>::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
+       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 convertToNative method. */
+    //return std::forward_as_tuple(this->getNativeValue<std::tuple_element_t<I, Arg_Ts>, I>(values)...);
+    return std::forward_as_tuple(
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+               convertToNative(values[I])...);
+  }
+
+  template<typename Proc_T>
+  VALUE NativeProc<Proc_T>::invoke(Arg_Ts&& nativeArgs)
+  {
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->proc_, std::forward<Arg_Ts>(nativeArgs));
+      return Qnil;
+    }
+    else
+    {
+      // Call the native method and get the result
+      Return_T nativeResult = std::apply(this->proc_, std::forward<Arg_Ts>(nativeArgs));
+
+      // Return the result
+      return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
+    }
+  }
+
+  template<typename Proc_T>
+  VALUE NativeProc<Proc_T>::operator()(size_t argc, const VALUE* argv, 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);
+
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+
+    // Convert the Ruby values to native values
+    Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+
+    // Now call the native method
+    VALUE result = this->invoke(std::forward<Arg_Ts>(nativeValues));
+
+    return result;
+  }
+
+  template<typename Proc_T>
+  inline std::string NativeProc< Proc_T>::name()
+  {
+    return "proc";
+  }
+
+  template<typename Proc_T>
+  inline NativeKind NativeProc< Proc_T>::kind()
+  {
+    return NativeKind::Proc;
+  }
+
+  template<typename Proc_T>
+  inline VALUE NativeProc<Proc_T>::returnKlass()
+  {
+    TypeMapper<Return_T> typeMapper;
+    return typeMapper.rubyKlass();
+  }
+}

data/rice/detail/NativeRegistry.hpp

@@ -25,8 +25,16 @@ namespace Rice::detail
   class NativeRegistry
   {
   public:
+    // std::is_copy_constructible returns true for std::vector<std::unique_ptr> - so we need
+    // to force the issue
+    NativeRegistry() = default;
+    NativeRegistry(const NativeRegistry& other) = delete;
+    NativeRegistry& operator=(const NativeRegistry& other) = delete;
+
     void add(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
     void reset(VALUE klass);
+
+    const std::vector<Native*> lookup(VALUE klass);
     const std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
 
   private:

data/rice/detail/NativeRegistry.ipp

@@ -33,6 +33,33 @@ namespace Rice::detail
     }
   }
   
+  inline const std::vector<Native*> NativeRegistry::lookup(VALUE klass)
+  {
+    std::vector<Native*> result;
+
+    if (rb_type(klass) == T_ICLASS)
+    {
+      klass = detail::protect(rb_class_of, klass);
+    }
+
+    for (auto& pair : this->natives_)
+    {
+      const std::pair<VALUE, ID>& key = pair.first;
+
+      if (klass == key.first)
+      {
+        const std::vector<std::unique_ptr<Native>>& value = pair.second;
+        for (auto& native : value)
+        {
+          result.push_back(native.get());
+        }
+      }
+    }
+
+    return result;
+  }
+
+
   inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)

data/rice/detail/Parameter.hpp

@@ -0,0 +1,47 @@
+#ifndef Rice__detail__Parameter__hpp_
+#define Rice__detail__Parameter__hpp_
+
+#include <optional>
+
+namespace Rice::detail
+{
+  class ParameterAbstract
+  {
+  public:
+    ParameterAbstract() = default;
+    ParameterAbstract(Arg* arg);
+    virtual ~ParameterAbstract() = default;
+
+    ParameterAbstract(ParameterAbstract&& other) = default;
+    ParameterAbstract& operator=(ParameterAbstract&& other) = default;
+
+    virtual Convertible matches(std::optional<VALUE>& valueOpt) = 0;
+    virtual std::string cppTypeName() = 0;
+    virtual VALUE klass() = 0;
+
+  public:
+    Arg* arg = nullptr;
+  };
+
+  template<typename T>
+  class Parameter: public ParameterAbstract
+  {
+   public:
+     using Type = T;
+
+     Parameter() = default;
+     Parameter(Arg* arg);
+     Parameter(Parameter&& other) = default;
+     Parameter& operator=(Parameter&& other) = default;
+
+     T convertToNative(std::optional<VALUE>& valueOpt);
+     Convertible matches(std::optional<VALUE>& valueOpt) override;
+     std::string cppTypeName() override;
+     VALUE klass() override;
+
+    // std::string typeName() override;
+  private:
+    From_Ruby<remove_cv_recursive_t<T>> fromRuby_;
+  };
+}
+#endif // Rice__detail__Parameter__hpp_