rice 3.0.0 → 4.0.0

data/rice/detail/NativeAttribute.hpp

@@ -0,0 +1,53 @@
+#ifndef Rice__detail__Native_Attribute__hpp_
+#define Rice__detail__Native_Attribute__hpp_
+
+#include "ruby.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "MethodInfo.hpp"
+
+namespace Rice
+{
+  enum class AttrAccess
+  {
+    ReadWrite,
+    Read,
+    Write
+  };
+
+  namespace detail
+  {
+    template<typename Return_T, typename Attr_T, typename Self_T = void>
+    class NativeAttribute
+    {
+    public:
+      using Native_Return_T = Return_T;
+
+      // Static member functions that Ruby calls
+      static VALUE get(VALUE self);
+      static VALUE set(VALUE self, VALUE value);
+
+    public:
+      NativeAttribute(Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+
+      // Invokes the wrapped function
+      VALUE read(VALUE self);
+      VALUE write(VALUE self, VALUE value);
+
+    private:
+      Attr_T attr_;
+      AttrAccess access_;
+    };
+
+    // A plain function or static member call
+    template<typename T>
+    auto* Make_Native_Attribute(T* attr, AttrAccess access);
+
+    // Lambda function that does not take Self as first parameter
+    template<typename Class_T, typename T>
+    auto* Make_Native_Attribute(T Class_T::* attr, AttrAccess access);
+  } // detail
+} // Rice
+
+#include "NativeAttribute.ipp"
+
+#endif // Rice__detail__Native_Attribute__hpp_

data/rice/detail/NativeAttribute.ipp

@@ -0,0 +1,83 @@
+#include <array>
+#include <algorithm>
+
+#include "rice_traits.hpp"
+#include "method_data.hpp"
+#include "to_ruby_defn.hpp"
+#include "../ruby_try_catch.hpp"
+
+namespace Rice::detail
+{
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::get(VALUE self)
+  {
+    RUBY_TRY
+    {
+      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
+      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
+      return attr->read(self);
+    }
+    RUBY_CATCH
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::set(VALUE self, VALUE value)
+  {
+    RUBY_TRY
+    {
+      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
+      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
+      return attr->write(self, value);
+    }
+    RUBY_CATCH
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  NativeAttribute<Return_T, Attr_T, Self_T>::NativeAttribute(Attr_T attr, AttrAccess access)
+    : attr_(attr), access_(access)
+  {
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::read(VALUE self)
+  {
+    using Unqualified_T = remove_cv_recursive_t<Return_T>;
+    if constexpr (std::is_member_object_pointer_v<Attr_T>)
+    {
+      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
+      return To_Ruby<Unqualified_T>().convert(nativeSelf->*attr_);
+    }
+    else
+    {
+      return To_Ruby<Unqualified_T>().convert(*attr_);
+    }
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::write(VALUE self, VALUE value)
+  {
+    if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>> && std::is_member_object_pointer_v<Attr_T>)
+    {
+      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
+      nativeSelf->*attr_ = From_Ruby<Return_T>().convert(value);
+    }
+    else if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>>)
+    {
+      *attr_ = From_Ruby<Return_T>().convert(value);
+    }
+    return value;
+  }
+
+  template<typename T>
+  auto* Make_Native_Attribute(T* attr, AttrAccess access)
+  {
+    return new NativeAttribute<T, T*>(attr, access);
+  }
+
+  template<typename Class_T, typename T>
+  auto* Make_Native_Attribute(T Class_T::* attr, AttrAccess access)
+  {
+    using Attr_T = T Class_T::*;
+    return new NativeAttribute<T, Attr_T, Class_T>(attr, access);
+  }
+} // Rice

data/rice/detail/NativeFunction.hpp

@@ -0,0 +1,69 @@
+#ifndef Rice__detail__Native_Function__hpp_
+#define Rice__detail__Native_Function__hpp_
+
+#include "ruby.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "MethodInfo.hpp"
+#include "function_traits.hpp"
+#include "from_ruby.hpp"
+
+namespace Rice::detail
+{
+  template<typename Function_T, bool IsMethod>
+  class NativeFunction
+  {
+  public:
+    // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
+    // have the concept of constants anyways
+    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
+    using Self_T = typename method_traits<Function_T, IsMethod>::Self_T;
+    using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
+    using From_Ruby_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+
+    // Static member function that Ruby calls
+    static VALUE call(int argc, VALUE* argv, VALUE self);
+
+  public:
+    NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo);
+
+    // Invokes the wrapped function
+    VALUE operator()(int argc, VALUE* argv, VALUE self);
+
+  private:
+    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_Ts createFromRuby(std::index_sequence<I...>& indices);
+
+    To_Ruby<Return_T> createToRuby();
+      
+    // Convert Ruby argv pointer to Ruby values
+    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
+
+    // Convert Ruby values to C++ values
+    template<typename std::size_t...I>
+    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
+
+    // Figure out what self is
+    Self_T getSelf(VALUE self);
+
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
+
+    // Call the underlying C++ function
+    VALUE invokeNativeFunction(Arg_Ts& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs);
+
+  private:
+    Function_T func_;
+    From_Ruby_Ts fromRubys_;
+    To_Ruby<Return_T> toRuby_;
+    std::shared_ptr<Exception_Handler> handler_;
+    std::unique_ptr<MethodInfo> methodInfo_;
+  };
+}
+#include "NativeFunction.ipp"
+
+#endif // Rice__detail__Native_Function__hpp_

data/rice/detail/NativeFunction.ipp

@@ -0,0 +1,248 @@
+#include <array>
+#include <algorithm>
+#include <stdexcept>
+
+#include "method_data.hpp"
+#include "to_ruby_defn.hpp"
+#include "../ruby_try_catch.hpp"
+
+namespace Rice::detail
+{
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::call(int argc, VALUE* argv, VALUE self)
+  {
+    using Wrapper_T = NativeFunction<Function_T, IsMethod>;
+    Wrapper_T* wrapper = detail::MethodData::data<Wrapper_T*>();
+    return wrapper->operator()(argc, argv, self);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  NativeFunction<Function_T, IsMethod>::NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo)
+    : func_(func), handler_(handler), methodInfo_(methodInfo)
+  {
+    // Create a tuple of NativeArgs that will convert the Ruby values to native values. For 
+    // builtin types NativeArgs will keep a copy of the native value so that it 
+    // can be passed by reference or pointer to the native function. For non-builtin types
+    // it will just pass the value through.
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    this->fromRubys_ = this->createFromRuby(indices);
+
+    this->toRuby_ = this->createToRuby();
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<typename T, std::size_t I>
+  From_Ruby<T> NativeFunction<Function_T, IsMethod>::createFromRuby()
+  {
+    // Does the From_Ruby instantiation work with Arg?
+    if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
+    {
+      return From_Ruby<T>(&this->methodInfo_->arg(I));
+    }
+    else
+    {
+      return From_Ruby<T>();
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  To_Ruby<typename NativeFunction<Function_T, IsMethod>::Return_T> NativeFunction<Function_T, IsMethod>::createToRuby()
+  {
+    // Does the From_Ruby instantiation work with ReturnInfo?
+    if constexpr (std::is_constructible_v<To_Ruby<Return_T>, Return*>)
+    {
+      return To_Ruby<Return_T>(&this->methodInfo_->returnInfo);
+    }
+    else
+    {
+      return To_Ruby<Return_T>();
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  typename NativeFunction<Function_T, IsMethod>::From_Ruby_Ts NativeFunction<Function_T, IsMethod>::createFromRuby(std::index_sequence<I...>& indices)
+  {
+    return std::make_tuple(createFromRuby<remove_cv_recursive_t<typename std::tuple_element<I, Arg_Ts>::type>, I>()...);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  std::vector<VALUE> NativeFunction<Function_T, IsMethod>::getRubyValues(int argc, VALUE* argv)
+  {
+    // Setup a tuple to contain required methodInfo to rb_scan_args
+    std::string scanFormat = this->methodInfo_->formatString();
+    std::tuple<int, VALUE*, const char*> rbScanMandatory = std::forward_as_tuple(argc, argv, scanFormat.c_str());
+
+    // Create a vector to store the variable number of Ruby Values
+    std::vector<VALUE> rbScanArgsOptional(std::tuple_size_v<Arg_Ts>, Qnil);
+
+    // Convert the vector to an array so it can then be concatenated to a tuple
+    std::array<VALUE*, std::tuple_size_v<Arg_Ts>> rbScanArgsOptionalPointers;
+    std::transform(rbScanArgsOptional.begin(), rbScanArgsOptional.end(), rbScanArgsOptionalPointers.begin(),
+      [](VALUE& value)
+      {
+        return &value;
+      });
+
+    // Combine the tuples and call rb_scan_args
+    auto rbScanArgs = std::tuple_cat(rbScanMandatory, rbScanArgsOptionalPointers);
+    std::apply(rb_scan_args, rbScanArgs);
+
+    return rbScanArgsOptional;
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  typename NativeFunction<Function_T, IsMethod>::Arg_Ts NativeFunction<Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
+     std::index_sequence<I...>& indices)
+  {
+    // Convert each Ruby value to its native value by calling the appropriate fromRuby instance.
+    // Note that for fundamental types From_Ruby<Arg_Ts> will keep a copy of the native value
+    // so it can be passed by reference or pointer to a native function.
+    return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(values[I])...);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  typename NativeFunction<Function_T, IsMethod>::Self_T NativeFunction<Function_T, IsMethod>::getSelf(VALUE self)
+  {
+    // There is no self parameter
+    if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
+    {
+      return nullptr;
+    }
+    // Self parameter is a Ruby VALUE so no conversion is needed
+    else if constexpr (std::is_same_v<Self_T, VALUE>)
+    {
+      return self;
+    }
+    // Self parameter could be derived from Object or it is an C++ instdance and
+    // needs to be unwrapped from Ruby
+    else
+    {
+      return From_Ruby<Self_T>().convert(self);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeFunction(Arg_Ts& nativeArgs)
+  {
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->func_, nativeArgs);
+      return Qnil;
+    }
+    else
+    {
+      // Call the native method and get the result
+      Return_T nativeResult = std::apply(this->func_, nativeArgs);
+      
+      // Return the result
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs)
+  {
+    Self_T receiver = this->getSelf(self);
+    auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), nativeArgs);
+
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->func_, selfAndNativeArgs);
+      return Qnil;
+    }
+    else
+    {
+      Return_T nativeResult = (Return_T)std::apply(this->func_, selfAndNativeArgs);
+
+      // 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<Self_T>>)
+      {
+        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Self_T>)
+        {
+          if (nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Self_T>)
+        {
+          if (nativeResult == &receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Self_T>)
+        {
+          if (&nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Self_T>)
+        {
+          if (&nativeResult == &receiver)
+            return self;
+        }
+      }
+
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  void NativeFunction<Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues)
+  {
+    // Check function arguments
+    Wrapper* selfWrapper = getWrapper(self);
+    for (const Arg& arg : (*this->methodInfo_))
+    {
+      if (arg.isKeepAlive)
+      {
+        selfWrapper->addKeepAlive(rubyValues[arg.position]);
+      }
+    }
+
+    // Check return value
+    if (this->methodInfo_->returnInfo.isKeepAlive)
+    {
+      Wrapper* returnWrapper = getWrapper(returnValue);
+      returnWrapper->addKeepAlive(self);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::operator()(int argc, VALUE* argv, VALUE self)
+  {
+    try
+    {
+      // Get the ruby values
+      std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv);
+
+      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 = Qnil;
+      if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
+      {
+        result = this->invokeNativeFunction(nativeValues);
+      }
+      else
+      {
+        result = this->invokeNativeMethod(self, nativeValues);
+      }
+
+      // Check if any function arguments or return values need to have their lifetimes tied to the receiver
+      this->checkKeepAlive(self, result, rubyValues);
+
+      return result;
+    }
+    catch (...)
+    {
+      RUBY_TRY
+      {
+        return this->handler_->handle_exception();
+      }
+      RUBY_CATCH
+    }
+  }
+}