rice 4.6.1 → 4.7.1

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,32 @@ 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_

data/rice/detail/Parameter.ipp

@@ -0,0 +1,105 @@
+namespace Rice::detail
+{
+  // -----------  ParameterAbstract ----------------
+  inline ParameterAbstract::ParameterAbstract(Arg* arg) : arg(arg)
+  {
+  }
+
+  // -----------  Parameter ----------------
+  template<typename T>
+  inline Parameter<T>::Parameter(Arg* arg) : ParameterAbstract(arg), fromRuby_(arg)
+  {
+  }
+
+  template<typename T>
+  inline Convertible Parameter<T>::matches(std::optional<VALUE>& valueOpt)
+  {
+    Convertible result = Convertible::None;
+
+    // Is a VALUE being passed directly to C++ ?
+    if (valueOpt.has_value())
+    {
+      VALUE value = valueOpt.value();
+      if (this->arg->isValue())
+      {
+        result = Convertible::Exact;
+      }
+      // If index is less than argc then check with FromRuby if the VALUE is convertible
+      // to C++.
+      else
+      {
+        result = this->fromRuby_.is_convertible(value);
+
+        // If this is an exact match check if the const-ness of the value and the parameter match
+        if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA)
+        {
+          // Check the constness of the Ruby wrapped value and the parameter
+          WrapperBase* wrapper = getWrapper(value);
+
+          // Do not send a const value to a non-const parameter
+          if (wrapper->isConst() && !is_const_any_v<T>)
+          {
+            result = Convertible::None;
+          }
+          // It is ok to send a non-const value to a const parameter but
+          // prefer non-const to non-const by slighly decreasing the convertible value
+          else if (!wrapper->isConst() && is_const_any_v<T>)
+          {
+            result = Convertible::Const;
+          }
+        }
+      }
+    }
+    // Last check if a default value has been set
+    else if (this->arg->hasDefaultValue())
+    {
+      result = Convertible::Exact;
+    }
+
+    return result;
+  }
+
+  template<typename T>
+  inline T Parameter<T>::convertToNative(std::optional<VALUE>& valueOpt)
+  {
+    /* In general the compiler will convert T to const T, but that does not work for converting
+       T** to const T** (see see https://isocpp.org/wiki/faq/const-correctness#constptrptr-conversion)
+       which comes up in the OpenCV bindings.
+
+       An alternative solution is updating From_Ruby#convert to become a templated function that specifies
+       the return type. That works but requires a lot more code changes for this one case and is not
+       backwards compatible. */
+
+    if constexpr (is_pointer_pointer_v<T> && !std::is_convertible_v<remove_cv_recursive_t<T>, T>)
+    {
+      return (T)this->fromRuby_.convert(valueOpt.value());
+    }
+    else if (valueOpt.has_value())
+    {
+      return this->fromRuby_.convert(valueOpt.value());
+    }
+    else if constexpr (std::is_constructible_v<std::remove_cv_t<T>, std::remove_cv_t<std::remove_reference_t<T>>&>)
+    {
+      if (this->arg->hasDefaultValue())
+      {
+        return this->arg->template defaultValue<T>();
+      }
+    }
+
+    throw std::invalid_argument("Could not convert Rubyy value");
+  }
+
+  template<typename T>
+  inline std::string Parameter<T>::cppTypeName()
+  {
+    detail::TypeMapper<T> typeMapper;
+    return typeMapper.simplifiedName();
+  }
+
+  template<typename T>
+  inline VALUE Parameter<T>::klass()
+  {
+    TypeMapper<T> typeMapper;
+    return typeMapper.rubyKlass();
+  }
+}

data/rice/detail/Proc.ipp

@@ -1,15 +1,17 @@
 namespace Rice::detail
 {
-  // Note Return_T(Arg_Ts...) is intentional versus Return_T(*)(Arg_Ts...). That is
-  // because the Type machinery strips all pointers/references/const/val etc to avoid
-  // having an explosion of Type definitions
   template<typename Return_T, typename ...Arg_Ts>
-  struct Type<Return_T(Arg_Ts...)>
+  struct Type<Return_T(*)(Arg_Ts...)>
   {
     static bool verify()
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cProc;
+    }
   };
 
   // Wraps a C++ function as a Ruby proc
@@ -19,17 +21,16 @@ namespace Rice::detail
   public:
     using Proc_T = Return_T(*)(Arg_Ts...);
 
-    VALUE convert(Proc_T proc)
-    {
-      using NativeFunction_T = NativeFunction<void, Proc_T, false>;
-      auto native = new NativeFunction_T(proc);
-      VALUE result = rb_proc_new(NativeFunction_T::procEntry, (VALUE)native);
+    To_Ruby() = default;
 
-      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
-      VALUE finalizer = rb_proc_new(NativeFunction_T::finalizerCallback, (VALUE)native);
-      rb_define_finalizer(result, finalizer);
+    explicit To_Ruby(Arg* arg)
+    {
+    }
 
-      return result;
+    VALUE convert(Proc_T proc)
+    {
+      // Wrap the C+++ function pointer as a Ruby Proc
+      return NativeProc<Proc_T>::createRubyProc(std::forward<Proc_T>(proc));
     }
   };
 

data/rice/detail/Registries.hpp

@@ -11,6 +11,7 @@ namespace Rice::detail
   public:
     HandlerRegistry handlers;
     InstanceRegistry instances;
+    ModuleRegistry modules;
     NativeRegistry natives;
     TypeRegistry types;
   };

data/rice/detail/RubyType.hpp

@@ -9,8 +9,6 @@ namespace Rice::detail
   class RubyType
   {
   };
-
-  void define_ruby_types();
 }
 
 #endif // Rice__detail__ruby__type__hpp_

data/rice/detail/RubyType.ipp

@@ -11,6 +11,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_NIL };
     static inline std::set<ruby_value_type> Narrowable = {  };
     static inline std::string packTemplate = "not supported";
+    static inline std::string name = "bool";
   };
 
   template<>
@@ -24,6 +25,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
     static inline std::string packTemplate = CHAR_MIN < 0 ? "c*" : "C*";
+    static inline std::string name = "String";
   };
 
   template<>
@@ -38,6 +40,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
     static inline std::string packTemplate = "c*";
+    static inline std::string name = "String";
   };
 
   template<>
@@ -52,6 +55,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
     static inline std::string packTemplate = "C*";
+    static inline std::string name = "String";
   };
 
   template<>
@@ -65,6 +69,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
     static inline std::string packTemplate = "s*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -78,6 +83,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
     static inline std::string packTemplate = "S*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -93,6 +99,7 @@ namespace Rice::detail
     // while int can go up to 4 billion
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
     static inline std::string packTemplate = "i*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -108,6 +115,7 @@ namespace Rice::detail
     // while int can go up to 4 billion
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
     static inline std::string packTemplate = "I*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -121,6 +129,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
     static inline std::string packTemplate = "l_*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -134,6 +143,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM};
     static inline std::string packTemplate = "L_*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -147,6 +157,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { };
     static inline std::string packTemplate = "q_*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -160,6 +171,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { };
     static inline std::string packTemplate = "Q_*";
+    static inline std::string name = "Integer";
   };
 
   template<>
@@ -173,6 +185,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM };
     static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FLOAT };
     static inline std::string packTemplate = "f*";
+    static inline std::string name = "Float";
   };
 
   template<>
@@ -186,6 +199,7 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
     static inline std::set<ruby_value_type> Narrowable = { };
     static inline std::string packTemplate = "d*";
+    static inline std::string name = "Float";
   };
 
   template<>
@@ -195,38 +209,6 @@ namespace Rice::detail
     static inline std::set<ruby_value_type> Exact = { };
     static inline std::set<ruby_value_type> Castable = { };
     static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string name = "void";
   };
-}
-
-namespace Rice::detail
-{
-  template<typename T>
-  inline Data_Type<T> define_ruby_type()
-  {
-    std::string name = detail::typeName(typeid(T*));
-    std::string klassName = detail::rubyClassName(name);
-    Identifier id(klassName);
-
-    Module rb_mRice = define_module("Rice");
-    return define_class_under<T>(rb_mRice, id);
-  }
-
-  inline void define_ruby_types()
-  {
-    define_ruby_type<bool>();
-    define_ruby_type<char>();
-    define_ruby_type<signed char>();
-    define_ruby_type<unsigned char>();
-    define_ruby_type<short>();
-    define_ruby_type<unsigned short>();
-    define_ruby_type<int>();
-    define_ruby_type<unsigned int>();
-    define_ruby_type<long>();
-    define_ruby_type<unsigned long>();
-    define_ruby_type<long long>();
-    define_ruby_type<unsigned long long>();
-    define_ruby_type<float>();
-    define_ruby_type<double>();
-    define_ruby_type<void>();
-  }
 }

data/rice/detail/Type.hpp

@@ -11,14 +11,50 @@ namespace Rice::detail
     static bool verify();
   };
 
-  // Return the name of a type
-  std::string typeName(const std::type_info& typeInfo);
-  std::string typeName(const std::type_index& typeIndex);
-  std::string cppClassName(const std::string& typeInfoName);
-  std::string rubyClassName(const std::string& typeInfoName);
-  std::string findGroup(std::string& string, size_t start = 0);
-  void replaceGroup(std::string& string, std::regex regex, std::string replacement);
-  void replaceAll(std::string& string, std::regex regex, std::string replacement);
+  template<typename T>
+  struct Type<T&>
+  {
+    static bool verify();
+  };
+
+  template<typename T>
+  struct Type<T&&>
+  {
+    static bool verify();
+  };
+
+  template<typename T>
+  struct Type<T*>
+  {
+    static bool verify();
+  };
+
+  template<typename T>
+  struct Type<T**>
+  {
+    static bool verify();
+  };
+
+  template<typename T>
+  class TypeMapper
+  {
+  public:
+    std::string name();
+    std::string name(const std::type_index& typeIndex);
+    std::string simplifiedName();
+    std::string rubyName();
+    VALUE rubyKlass();
+
+    // public only for testing
+    std::string findGroup(std::string& string, size_t start = 0);
+  private:
+    std::string demangle(char const* mangled_name);
+    std::string rubyTypeName();
+    void removeGroup(std::string& string, std::regex regex);
+    void replaceGroup(std::string& string, std::regex regex, std::string replacement);
+    void replaceAll(std::string& string, std::regex regex, std::string replacement);
+    void capitalizeHelper(std::string& content, std::regex& regex);
+  };
 
   template<typename T>
   void verifyType();