rice 4.7.1 → 4.8.0

data/rice/detail/Parameter.ipp

@@ -1,64 +1,72 @@
 namespace Rice::detail
 {
   // -----------  ParameterAbstract ----------------
-  inline ParameterAbstract::ParameterAbstract(Arg* arg) : arg(arg)
+  inline ParameterAbstract::ParameterAbstract(std::unique_ptr<Arg>&& arg) : arg_(std::move(arg))
   {
   }
 
+  inline ParameterAbstract::ParameterAbstract(const ParameterAbstract& other)
+  {
+    this->arg_ = std::make_unique<Arg>(*other.arg_);
+  }
+
+  inline Arg* ParameterAbstract::arg()
+  {
+    return this->arg_.get();
+  }
+
   // -----------  Parameter ----------------
   template<typename T>
-  inline Parameter<T>::Parameter(Arg* arg) : ParameterAbstract(arg), fromRuby_(arg)
+  inline Parameter<T>::Parameter(std::unique_ptr<Arg>&& arg) : ParameterAbstract(std::move(arg)), 
+    fromRuby_(this->arg()), toRuby_(this->arg())
   {
   }
 
   template<typename T>
-  inline Convertible Parameter<T>::matches(std::optional<VALUE>& valueOpt)
+  inline double Parameter<T>::matches(std::optional<VALUE>& valueOpt)
   {
-    Convertible result = Convertible::None;
+    if (!valueOpt.has_value())
+    {
+      return Convertible::None;
+    }
+    else if (this->arg()->isValue())
+    {
+      return Convertible::Exact;
+    }
 
-    // Is a VALUE being passed directly to C++ ?
-    if (valueOpt.has_value())
+    VALUE value = valueOpt.value();
+
+    // Check with FromRuby if the VALUE is convertible to C++
+    double result = this->fromRuby_.is_convertible(value);
+
+    // If this is an exact match check if the const-ness of the value and the parameter match.
+    // One caveat - procs are also RUBY_T_DATA so don't check if this is a function type
+    if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA && !std::is_function_v<std::remove_pointer_t<T>>)
     {
-      VALUE value = valueOpt.value();
-      if (this->arg->isValue())
+      // 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::Exact;
+        result = Convertible::None;
       }
-      // If index is less than argc then check with FromRuby if the VALUE is convertible
-      // to C++.
-      else
+      // It is ok to send a non-const value to a const parameter but
+      // prefer non-const to non-const by slightly decreasing the score
+      else if (!wrapper->isConst() && is_const_any_v<T>)
       {
-        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;
-          }
-        }
+        result = Convertible::ConstMismatch;
       }
     }
-    // Last check if a default value has been set
-    else if (this->arg->hasDefaultValue())
-    {
-      result = Convertible::Exact;
-    }
 
     return result;
   }
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4702)  // unreachable code
+#endif
+
   template<typename T>
   inline T Parameter<T>::convertToNative(std::optional<VALUE>& valueOpt)
   {
@@ -78,22 +86,73 @@ namespace Rice::detail
     {
       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>>&>)
+    // Remember std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
+    // So special case vector handling
+    else if constexpr (detail::is_std_vector_v<detail::intrinsic_type<T>>)
+    {
+      if constexpr (std::is_copy_constructible_v<typename detail::intrinsic_type<T>::value_type>)
+      {
+        if (this->arg()->hasDefaultValue())
+        {
+          return this->arg()->template defaultValue<T>();
+        }
+      }
+    }
+    else if constexpr (std::is_copy_constructible_v<T>)
     {
-      if (this->arg->hasDefaultValue())
+      if (this->arg()->hasDefaultValue())
+      {
+        return this->arg()->template defaultValue<T>();
+      }
+    }
+
+    // This can be unreachable code
+    throw std::invalid_argument("Could not convert Ruby value");
+  }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+  template<typename T>
+  inline VALUE Parameter<T>::convertToRuby(T& object)
+  {
+    return this->toRuby_.convert(object);
+  }
+
+  template<typename T>
+  inline VALUE Parameter<T>::defaultValueRuby()
+  {
+    if constexpr (std::is_constructible_v<std::remove_cv_t<T>, std::remove_cv_t<std::remove_reference_t<T>>&>)
+    {
+      // Remember std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
+      // So special case vector handling
+      if constexpr (detail::is_std_vector_v<detail::intrinsic_type<T>>)
+      {
+        if constexpr (std::is_copy_constructible_v<typename detail::intrinsic_type<T>::value_type>)
+        {
+          if (this->arg()->hasDefaultValue())
+          {
+            T defaultValue = this->arg()->template defaultValue<T>();
+            return this->toRuby_.convert(defaultValue);
+          }
+        }
+      }
+      else if (this->arg()->hasDefaultValue())
       {
-        return this->arg->template defaultValue<T>();
+        T defaultValue = this->arg()->template defaultValue<T>();
+        return this->toRuby_.convert((remove_cv_recursive_t<T>)defaultValue);
       }
     }
 
-    throw std::invalid_argument("Could not convert Rubyy value");
+    throw std::runtime_error("No default value set for parameter " + this->arg()->name);
   }
 
   template<typename T>
   inline std::string Parameter<T>::cppTypeName()
   {
-    detail::TypeMapper<T> typeMapper;
-    return typeMapper.simplifiedName();
+    detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    return typeIndexParser.simplifiedName();
   }
 
   template<typename T>

data/rice/detail/Proc.ipp

@@ -1,7 +1,7 @@
 namespace Rice::detail
 {
-  template<typename Return_T, typename ...Arg_Ts>
-  struct Type<Return_T(*)(Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  struct Type<Return_T(*)(Parameter_Ts...)>
   {
     static bool verify()
     {
@@ -15,15 +15,15 @@ namespace Rice::detail
   };
 
   // Wraps a C++ function as a Ruby proc
-  template<typename Return_T, typename ...Arg_Ts>
-  class To_Ruby<Return_T(*)(Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  class To_Ruby<Return_T(*)(Parameter_Ts...)>
   {
   public:
-    using Proc_T = Return_T(*)(Arg_Ts...);
+    using Proc_T = Return_T(*)(Parameter_Ts...);
 
     To_Ruby() = default;
 
-    explicit To_Ruby(Arg* arg)
+    explicit To_Ruby(Arg*)
     {
     }
 
@@ -35,11 +35,11 @@ namespace Rice::detail
   };
 
   // Makes a Ruby proc callable as C callback
-  template<typename Return_T, typename ...Arg_Ts>
-  class From_Ruby<Return_T(*)(Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  class From_Ruby<Return_T(*)(Parameter_Ts...)>
   {
   public:
-    using Callback_T = Return_T(*)(Arg_Ts...);
+    using Callback_T = Return_T(*)(Parameter_Ts...);
 
     From_Ruby() = default;
 
@@ -47,9 +47,9 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      if (protect(rb_obj_is_proc, value) == Qtrue || protect(rb_proc_lambda_p, value))
+      if (protect(rb_obj_is_proc, value) == Qtrue || protect(rb_proc_lambda_p, value) == Qtrue)
       {
         return Convertible::Exact;
       }
@@ -59,26 +59,12 @@ namespace Rice::detail
       }
     }
 
-#ifdef HAVE_LIBFFI
     Callback_T convert(VALUE value)
     {
-      using NativeCallback_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
-      NativeCallback_T* nativeCallback = new NativeCallback_T(value);
-
-      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
-      VALUE finalizer = rb_proc_new(NativeCallback_T::finalizerCallback, (VALUE)nativeCallback);
-      rb_define_finalizer(value, finalizer);
-
-      return nativeCallback->callback();
-    }
-#else
-    Callback_T convert(VALUE value)
-    {
-      using NativeCallback_T = NativeCallbackSimple<Return_T(*)(Arg_Ts...)>;
-      NativeCallback_T::proc = value;
-      return &NativeCallback_T::callback;
+      using NativeCallback_T = NativeCallback<Callback_T>;
+      NativeCallback_T* callback = new NativeCallback_T(value);
+      return callback->callback();
     }
-#endif
 
   private:
     Arg* arg_ = nullptr;

data/rice/detail/RubyType.ipp

@@ -7,9 +7,6 @@ namespace Rice::detail
     using FromRuby_T = bool(*)(VALUE);
 
     static inline FromRuby_T fromRuby = RB_TEST;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_TRUE, RUBY_T_FALSE };
-    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";
   };
@@ -21,9 +18,6 @@ namespace Rice::detail
     using FromRuby_T = char(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2char_inline;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -32,13 +26,9 @@ namespace Rice::detail
   class RubyType<signed char>
   {
   public:
-    // Hack - need to later typecast
-    using FromRuby_T = char(*)(VALUE);
+    using FromRuby_T =  char(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2char_inline;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -47,13 +37,9 @@ namespace Rice::detail
   class RubyType<unsigned char>
   {
   public:
-    // Hack - need to later typecast, although char's in ruby are unsigned
     using FromRuby_T = char(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2char_inline;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -65,9 +51,6 @@ namespace Rice::detail
     using FromRuby_T = short(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2short_inline;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -79,9 +62,6 @@ namespace Rice::detail
     using FromRuby_T = unsigned short(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2ushort;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -93,11 +73,6 @@ namespace Rice::detail
     using FromRuby_T = int(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2int_inline;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
-    static inline std::set<ruby_value_type> Castable = { };
-    // We allow bignum to integer because Ruby switches to bignum at about 2 billion on 64 bit systems,
-    // 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";
   };
@@ -109,11 +84,6 @@ namespace Rice::detail
     using FromRuby_T = unsigned int(*)(VALUE);
 
     static inline FromRuby_T fromRuby = RB_NUM2UINT;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
-    static inline std::set<ruby_value_type> Castable = { };
-    // We allow bignum to integer because Ruby switches to bignum at about 2 billion on 64 bit systems,
-    // 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";
   };
@@ -125,9 +95,6 @@ namespace Rice::detail
     using FromRuby_T = long(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2long_inline;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
-    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";
   };
@@ -139,9 +106,6 @@ namespace Rice::detail
     using FromRuby_T = unsigned long(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2ulong_inline;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM  };
-    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";
   };
@@ -153,9 +117,6 @@ namespace Rice::detail
     using FromRuby_T = long long(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2ll_inline;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
-    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";
   };
@@ -167,9 +128,6 @@ namespace Rice::detail
     using FromRuby_T = unsigned long long(*)(VALUE);
 
     static inline FromRuby_T fromRuby = RB_NUM2ULL;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
-    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";
   };
@@ -181,9 +139,6 @@ namespace Rice::detail
     using FromRuby_T = double(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2dbl;
-    static inline std::set<ruby_value_type> Exact = { };
-    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";
   };
@@ -195,9 +150,6 @@ namespace Rice::detail
     using FromRuby_T = double(*)(VALUE);
 
     static inline FromRuby_T fromRuby = rb_num2dbl;
-    static inline std::set<ruby_value_type> Exact = { RUBY_T_FLOAT };
-    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";
   };
@@ -206,9 +158,6 @@ namespace Rice::detail
   class RubyType<void>
   {
   public:
-    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";
   };
-}
+}

data/rice/detail/Type.hpp

@@ -35,25 +35,41 @@ namespace Rice::detail
     static bool verify();
   };
 
-  template<typename T>
-  class TypeMapper
+  class TypeIndexParser
   {
   public:
+    TypeIndexParser(const std::type_index& typeIndex, bool isFundamental = false);
     std::string name();
-    std::string name(const std::type_index& typeIndex);
     std::string simplifiedName();
-    std::string rubyName();
-    VALUE rubyKlass();
+    std::string rubyName(std::string rubyTypeName);
 
     // 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);
+    void replaceAll(std::string& string, std::regex regex, std::string replacement);
+
+  private:
+    const std::type_index typeIndex_;
+    bool isFundamental_ = false;
+  };
+
+  template<typename T>
+  class TypeMapper
+  {
+  public:
+    VALUE rubyKlass();
+    std::string rubyName();
+
+  private:
+    std::string rubyTypeName();
+  
+  private:
+    TypeIndexParser typeIndexParser_{ typeid(T), std::is_fundamental_v<intrinsic_type<T>> };
   };
 
   template<typename T>