rice 4.6.1 → 4.7.0

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();