rice 4.6.1 → 4.7.0

data/rice/detail/NativeInvoker.hpp

@@ -0,0 +1,74 @@
+#ifndef Rice__detail__native_invoker__hpp_
+#define Rice__detail__native_invoker__hpp_
+
+#include <optional>
+
+namespace Rice::detail
+{
+  template<typename Return_T>
+  class ResultWrapper
+  {
+  public:
+    std::exception_ptr exception;
+    Return_T getResult();
+		void setResult(Return_T&& value);
+  private:
+    std::optional<Return_T> result_;
+  };
+
+  template<typename Return_T>
+  class ResultWrapper<Return_T&>
+  {
+  public:
+    std::exception_ptr exception;
+    Return_T& getResult();
+    void setResult(Return_T& value);
+  private:
+    std::optional<std::reference_wrapper<Return_T>> result_;
+  };
+
+  template<typename Return_T>
+  class ResultWrapper<Return_T*>
+  {
+  public:
+    std::exception_ptr exception;
+
+    Return_T* getResult();
+    void setResult(Return_T* value);
+  private:
+    Return_T* result_;
+  };
+
+  template<>
+  class ResultWrapper<void>
+  {
+  public:
+    std::exception_ptr exception;
+  };
+
+  template<typename Return_T, typename Function_T, typename Tuple_T>
+  class NativeInvoker
+  {
+  public:
+    const Function_T func;
+    Tuple_T args;
+  public:
+    NativeInvoker(const Function_T func, Tuple_T&& args);
+    void invoke();
+    Return_T result();
+    std::exception_ptr exception();
+  private:
+    ResultWrapper<Return_T> resultWrapper;
+  };
+
+  template<typename Function_T, typename ...Arg_Ts>
+  auto protect(Function_T func, Arg_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 Tuple_T>
+  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Tuple_T&& args);
+}
+
+#endif // Rice__detail__native_invoker__hpp_

data/rice/detail/NativeInvoker.ipp

@@ -0,0 +1,197 @@
+namespace Rice::detail
+{
+  // ----- ResultWrapper -------
+  template<typename Return_T>
+  inline Return_T ResultWrapper<Return_T>::getResult()
+  {
+    if constexpr (!std::is_copy_constructible_v<Return_T> && std::is_move_constructible_v<Return_T>)
+    {
+      return std::move(this->result_.value());
+    }
+    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> return 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>)
+      {
+        return std::move(this->result_.value());
+      }
+      else
+      {
+        return this->result_.value();
+      }
+    }
+    else
+    {
+      return this->result_.value();
+    }
+	}
+
+  template<typename Return_T>
+  inline void ResultWrapper<Return_T>::setResult(Return_T&& value)
+  {
+    if constexpr(std::is_copy_assignable_v<Return_T> || std::is_move_assignable_v<Return_T>)
+    {
+      this->result_ = std::forward<Return_T>(value);
+    }
+    else if constexpr (std::is_copy_constructible_v<Return_T>)
+    {
+      this->result_.emplace(value);
+    }
+    else if constexpr (std::is_move_constructible_v<Return_T>)
+    {
+      this->result_.emplace(std::move(value));
+    }
+  }
+
+  template<typename Return_T>
+  inline Return_T& ResultWrapper<Return_T&>::getResult()
+  {
+    return this->result_.value().get();
+  }
+
+  template<typename Return_T>
+  inline void ResultWrapper<Return_T&>::setResult(Return_T& value)
+  {
+    this->result_ = value;
+  }
+
+  template<typename Return_T>
+  inline Return_T* ResultWrapper<Return_T*>::getResult()
+  {
+    return this->result_;
+  }
+
+  template<typename Return_T>
+  inline void ResultWrapper<Return_T*>::setResult(Return_T* value)
+  {
+    this->result_ = value;
+  }
+
+  // ----- Invoker -------
+  template<typename Return_T, typename Function_T, typename Tuple_T>
+  inline NativeInvoker<Return_T, Function_T, Tuple_T>::NativeInvoker(const Function_T func, Tuple_T&& args)
+    : func(func), args(std::forward<Tuple_T>(args))
+  {
+  }
+
+  template<typename Return_T, typename Function_T, typename Tuple_T>
+  inline void NativeInvoker<Return_T, Function_T, Tuple_T>::invoke()
+  {
+    try
+    {
+      if constexpr (std::is_void_v<Return_T>)
+      {
+        std::apply(this->func, std::forward<Tuple_T>(this->args));
+      }
+      else if constexpr (!std::is_pointer_v<Return_T> && !std::is_reference_v<Return_T> && !std::is_copy_assignable_v<Return_T> && std::is_move_assignable_v<Return_T>)
+      {
+        this->resultWrapper.setResult(std::move(std::apply(this->func, std::forward<Tuple_T>(this->args))));
+      }
+      else
+      {
+        this->resultWrapper.setResult(std::forward<Return_T>(std::apply(this->func, std::forward<Tuple_T>(this->args))));
+      }
+    }
+    catch (...)
+    {
+      this->resultWrapper.exception = std::current_exception();
+    }
+  }
+
+  template<typename Return_T, typename Function_T, typename Tuple_T>
+  inline Return_T NativeInvoker<Return_T, Function_T, Tuple_T>::result()
+  {
+		return this->resultWrapper.getResult();
+  }
+
+  template<typename Return_T, typename Function_T, typename Tuple_T>
+  inline std::exception_ptr NativeInvoker<Return_T, Function_T, Tuple_T>::exception()
+  {
+    return this->resultWrapper.exception;
+  }
+
+  // ------- 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)
+  {
+    using Return_T = typename function_traits<Function_T>::return_type;
+    using Tuple_T = std::tuple<Arg_Ts...>;
+    using Invoker_T = NativeInvoker<Return_T, Function_T, Tuple_T>;
+
+    Tuple_T argsTuple = std::forward_as_tuple(args...);
+    Invoker_T invoker(func, std::forward<Tuple_T>(argsTuple));
+
+    auto trampoline = [](VALUE value) -> VALUE
+      {
+        Invoker_T* function = (Invoker_T*)value;
+
+        function->invoke();
+        return Qnil;
+      };
+
+    // Create Invoker and call it via ruby
+    int state = (int)JumpException::RUBY_TAG_NONE;
+    rb_protect(trampoline, (VALUE)(&invoker), &state);
+
+    // Did anything go wrong?
+    if (state == JumpException::RUBY_TAG_NONE)
+    {
+      if constexpr (!std::is_same_v<Return_T, void>)
+      {
+        return invoker.result();
+      }
+    }
+    else
+    {
+      VALUE err = rb_errinfo();
+      if (state == JumpException::RUBY_TAG_RAISE && RB_TEST(err))
+      {
+        rb_set_errinfo(Qnil);
+        throw Rice::Exception(err);
+      }
+      else
+      {
+        throw Rice::JumpException((Rice::JumpException::ruby_tag_type)state);
+      }
+    }
+  }
+
+  template<typename Function_T, typename ...Arg_Ts>
+  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Arg_Ts...args)
+  {
+    using Tuple_T = std::tuple<Arg_Ts...>;
+    Tuple_T argsTuple = std::forward_as_tuple(args...);
+    return no_gvl(func, argsTuple);
+  }
+
+  template<typename Function_T, typename Tuple_T>
+  typename function_traits<Function_T>::return_type no_gvl(Function_T func, Tuple_T&& args)
+  {
+    using Return_T = typename function_traits<Function_T>::return_type;
+    using Invoker_T = NativeInvoker<Return_T, Function_T, Tuple_T>;
+
+    Invoker_T invoker(func, std::forward<Tuple_T>(args));
+
+    auto trampoline = [](void* functor) -> void*
+      {
+        Invoker_T* function = (Invoker_T*)functor;
+        function->invoke();
+
+        if (function->exception())
+        {
+          std::rethrow_exception(function->exception());
+        }
+
+        return nullptr;
+      };
+
+    // Create Invoker and call it via ruby
+    rb_thread_call_without_gvl(trampoline, &invoker, nullptr, nullptr);
+
+    if constexpr (!std::is_same_v<Return_T, void>)
+    {
+      return invoker.result();
+    }
+  }
+}

data/rice/detail/NativeIterator.hpp

@@ -30,6 +30,10 @@ namespace Rice::detail
     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;
+
   protected:
     NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);
 

data/rice/detail/NativeIterator.ipp

@@ -101,4 +101,23 @@ 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()
+  {
+    return NativeKind::Iterator;
+  }
+
+  template<typename T, typename Iterator_Func_T>
+  inline VALUE NativeIterator<T, Iterator_Func_T>::returnKlass()
+  {
+    TypeMapper<Value_T> typeMapper;
+    return typeMapper.rubyKlass();
+  }
 }

data/rice/detail/NativeMethod.hpp

@@ -0,0 +1,97 @@
+#ifndef Rice__detail__Native_Method__hpp_
+#define Rice__detail__Native_Method__hpp_
+
+namespace Rice::detail
+{
+  //! The NativeMethod class calls C++ functions/methods/lambdas on behalf of Ruby
+  /*! The NativeMethod class is an intermediate between Ruby and C++. Every method
+   *  defined in Rice is associated with a NativeFuntion instance that is stored in
+   *  a unordered_map maintained by the MethodData class. The key is the Ruby class
+   *  and method.
+   * 
+   *  When Ruby calls into C++ it invokes the static NativeMethod.call method. This
+   *  method then looks up the NativeMethod instance and calls its ->() operator.
+   *
+   *  The instance then converts each of the arguments passed from Ruby into their
+   *  C++ equivalents. It then retrieves the C++ object (if there is one, Ruby could
+   *  be calling a free standing method or lambda). Then it calls the C++ method
+   *  and gets back the result. If there is a result (so not void), it is converted
+   *  from a C++ object to a Ruby object and returned back to Ruby.
+   * 
+   *  This class make heavy use of C++ Template metaprogramming to determine
+   *  the types and parameters a method takes. It then uses that information
+   *  to perform type conversion Ruby to C++.
+   *   
+   *  @tparam Receiver_T - The type of C++ class wrapped by Ruby. Althought NativeMethod
+   *    can derive the C++ class (Receiver_T), it can differ per member function. For example,
+   *    std::map has a size() method but that is actually implemented on an ancestor class _Tree.
+   *    Thus Receiver_T is std::map but Method_T::Receiver_T is _Tree. This breaks Rice in two ways. 
+   *    First, _Tree is not a registered type. Second, Rice would return a _Tree instance back to
+   *    C++ and not a std::map.
+   *  @tparam Method_T - A template that represents the C++ function
+   *    to call. This typename is automatically deduced by the compiler.
+   *  @tparam IsMethod - A boolean specifying whether the function has
+   *    a self parameter or not. Rice differentiates these two cases by
+   *    calling them methods (self) or functions (no self).
+   */
+
+  template<typename Class_T, typename Method_T>
+  class NativeMethod: Native
+  {
+  public:
+    using NativeMethod_T = NativeMethod<Class_T, Method_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 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 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);
+
+  public:
+    NativeMethod(VALUE klass, std::string method_name, Method_T method, 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:
+
+    template<std::size_t...I>
+    std::vector<std::string> argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices);
+
+    // 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);
+
+    // 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_;
+  };
+}
+
+#endif // Rice__detail__Native_Method__hpp_