rice 4.7.1 → 4.8.0

data/rice/detail/NativeMethod.ipp

@@ -6,13 +6,14 @@
 
 namespace Rice::detail
 {
-  template<typename Class_T, typename Method_T>
-  void NativeMethod<Class_T, Method_T>::define(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  template<typename ...Arg_Ts>
+  void NativeMethod<Class_T, Method_T, NoGVL>::define(VALUE klass, std::string method_name, Method_T method, Arg_Ts&& ...args)
   {
-    // Verify return and argument types
-    Native::verify_type<Return_T>(methodInfo->returnInfo()->isBuffer());
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    Native::verify_args<Arg_Ts>(methodInfo, indices);
+    // Verify return type
+    using Arg_Tuple = std::tuple<Arg_Ts...>;
+    constexpr bool isBuffer = tuple_element_index_v<Arg_Tuple, ReturnBuffer> < std::tuple_size_v<Arg_Tuple>;
+    Native::verify_type<Return_T, isBuffer>();
 
     // Have we defined this method yet in Ruby?
     Identifier identifier(method_name);
@@ -23,24 +24,29 @@ namespace Rice::detail
       detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
     }
 
-    // Create a NativeMethod instance and save it to the NativeRegistry. There may be multiple
-    // NativeMethod instances for a specific method because C++ supports method overloading.
-    NativeMethod_T* NativeMethod = new NativeMethod_T(klass, method_name, std::forward<Method_T>(method), methodInfo);
-    std::unique_ptr<Native> native(NativeMethod);
+    // Create method parameters - this will also validate their types
+    std::vector<std::unique_ptr<ParameterAbstract>> parameters = Native::create_parameters<Parameter_Ts>(args...);
+
+    // Create return info
+    std::unique_ptr<Return> returnInfo = Native::create_return<Arg_Ts...>(args...);
+    
+    // Create native method
+    NativeMethod_T* nativeMethod = new NativeMethod_T(klass, method_name, std::forward<Method_T>(method), std::move(returnInfo), std::move(parameters));
+    std::unique_ptr<Native> native(nativeMethod);
+
+    // Register the native method
     detail::Registries::instance.natives.add(klass, identifier.id(), native);
   }
 
-  template<typename Class_T, typename Method_T>
-  NativeMethod<Class_T, Method_T>::NativeMethod(VALUE klass, std::string method_name, Method_T method, MethodInfo* methodInfo)
-    : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
-      klass_(klass), method_name_(method_name), method_(method), methodInfo_(methodInfo),
-      toRuby_(methodInfo->returnInfo())
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  NativeMethod<Class_T, Method_T, NoGVL>::NativeMethod(VALUE klass, std::string method_name, Method_T method, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters)
+    : Native(method_name, std::move(returnInfo), std::move(parameters)),
+      klass_(klass), method_(method), toRuby_(returnInfo_.get())
   {
   }
 
-  template<typename Class_T, typename Method_T>
-  template<std::size_t... I>
-  std::vector<std::string> NativeMethod<Class_T, Method_T>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  std::vector<std::string> NativeMethod<Class_T, Method_T, NoGVL>::argTypeNames()
   {
     std::vector<std::string> result;
     for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
@@ -50,26 +56,25 @@ namespace Rice::detail
     return result;
   }
 
-  template<typename Class_T, typename Method_T>
-  std::string NativeMethod<Class_T, Method_T>::toString()
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  std::string NativeMethod<Class_T, Method_T, NoGVL>::toString()
   {
     std::ostringstream result;
 
-    detail::TypeMapper<Return_T> typeReturnMapper;
-    result << typeReturnMapper.simplifiedName() << " ";
+    detail::TypeIndexParser typeIndexParserReturn(typeid(Return_T), std::is_fundamental_v<detail::intrinsic_type<Return_T>>);
+    result << typeIndexParserReturn.simplifiedName() << " ";
     
     if (!std::is_null_pointer_v<Receiver_T>)
     {
-      detail::TypeMapper<Receiver_T> typeReceiverMapper;
-      result << typeReceiverMapper.simplifiedName() << "::";
+      detail::TypeIndexParser typeIndexParserReceiver(typeid(Receiver_T), std::is_fundamental_v<detail::intrinsic_type<Receiver_T>>);
+      result << typeIndexParserReceiver.simplifiedName() << "::";
     }
     
-    result << this->method_name_;
+    result << this->name();
 
     result << "(";
 
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    std::vector<std::string> argTypeNames = this->argTypeNames(result, indices);
+    std::vector<std::string> argTypeNames = this->argTypeNames();
     for (size_t i = 0; i < argTypeNames.size(); i++)
     {
       result << argTypeNames[i];
@@ -80,22 +85,22 @@ namespace Rice::detail
     return result.str();
   }
     
-  template<typename Class_T, typename Method_T>
+  template<typename Class_T, typename Method_T, bool NoGVL>
   template<std::size_t... I>
-  typename NativeMethod<Class_T, Method_T>::Apply_Args_T NativeMethod<Class_T, Method_T>::getNativeValues(VALUE self, std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices)
+  typename NativeMethod<Class_T, Method_T, NoGVL>::Apply_Args_T NativeMethod<Class_T, Method_T, NoGVL>::getNativeValues(VALUE self, std::vector<std::optional<VALUE>>& values, const std::index_sequence<I...>&)
   {
     /* 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++ method. Arg_T may have const/volatile while
+       on the arguments (Parameter_Ts) required by the C++ method. 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->getReceiver(self),
-      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Parameter_Ts>>*>(this->parameters_[I].get()))->
                convertToNative(values[I])...);
   }
 
-  template<typename Class_T, typename Method_T>
-  typename NativeMethod<Class_T, Method_T>::Receiver_T NativeMethod<Class_T, Method_T>::getReceiver(VALUE self)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  typename NativeMethod<Class_T, Method_T, NoGVL>::Receiver_T NativeMethod<Class_T, Method_T, NoGVL>::getReceiver(VALUE self)
   {
     // Self parameter is a Ruby VALUE so no conversion is needed
     if constexpr (std::is_same_v<Receiver_T, VALUE>)
@@ -129,8 +134,8 @@ namespace Rice::detail
     }
   }
 
-  template<typename Class_T, typename Method_T>
-  inline VALUE NativeMethod<Class_T, Method_T>::invoke(VALUE self, Apply_Args_T&& nativeArgs)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  inline VALUE NativeMethod<Class_T, Method_T, NoGVL>::invoke(VALUE self, Apply_Args_T&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
@@ -173,8 +178,8 @@ namespace Rice::detail
     }
   }
 
-  template<typename Class_T, typename Method_T>
-  inline VALUE NativeMethod<Class_T, Method_T>::invokeNoGVL(VALUE self, Apply_Args_T&& nativeArgs)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  inline VALUE NativeMethod<Class_T, Method_T, NoGVL>::invokeNoGVL(VALUE self, Apply_Args_T&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
@@ -217,77 +222,17 @@ namespace Rice::detail
     }
   }
 
-  template<typename Class_T, typename Method_T>
-  inline void NativeMethod<Class_T, Method_T>::noWrapper(const VALUE klass, const std::string& wrapper)
-  {
-    std::stringstream message;
-
-    message << "When calling the method `";
-    message << this->method_name_;
-    message << "' we could not find the wrapper for the '";
-    message << rb_obj_classname(klass);
-    message << "' ";
-    message << wrapper;
-    message << " type. You should not use keepAlive() on a Return or Arg that is a builtin Rice type.";
-
-    throw std::runtime_error(message.str());
-  }
-
-  template<typename Class_T, typename Method_T>
-  void NativeMethod<Class_T, Method_T>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
-  {
-    // Self will be Qnil for wrapped procs
-    if (self == Qnil)
-      return;
-
-    // selfWrapper will be nullptr if this(self) is a builtin type and not an external(wrapped) type
-    // it is highly unlikely that keepAlive is used in this case but we check anyway
-    WrapperBase* selfWrapper = getWrapper(self);
-
-    // Check method arguments
-    for (const Arg& arg : (*this->methodInfo_))
-    {
-      if (arg.isKeepAlive())
-      {
-        if (selfWrapper == nullptr)
-        {
-          noWrapper(self, "self");
-        }
-        selfWrapper->addKeepAlive(rubyValues[arg.position].value());
-      }
-    }
-
-    // Check return value
-    if (this->methodInfo_->returnInfo()->isKeepAlive())
-    {
-      if (selfWrapper == nullptr)
-      {
-        noWrapper(self, "self");
-      }
-
-      // returnWrapper will be nullptr if returnValue is a built-in type and not an external(wrapped) type
-      WrapperBase* returnWrapper = getWrapper(returnValue);
-      if (returnWrapper == nullptr)
-      {
-        noWrapper(returnValue, "return");
-      }
-      returnWrapper->addKeepAlive(self);
-    }
-  }
-
-  template<typename Class_T, typename Method_T>
-  VALUE NativeMethod<Class_T, Method_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  VALUE NativeMethod<Class_T, Method_T, NoGVL>::operator()(std::map<std::string, VALUE>& values, 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>>{};
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(values, true);
+    auto indices = std::make_index_sequence<std::tuple_size_v<Parameter_Ts>>{};
     Apply_Args_T nativeArgs = this->getNativeValues(self, rubyValues, indices);
 
-    bool noGvl = this->methodInfo_->function()->isNoGvl();
-
     VALUE result = Qnil;
 
-    if (noGvl)
+    if constexpr (NoGVL)
     {
       result = this->invokeNoGVL(self, std::forward<Apply_Args_T>(nativeArgs));
     }
@@ -302,25 +247,20 @@ namespace Rice::detail
     return result;
   }
 
-  template<typename Class_T, typename Method_T>
-  inline std::string NativeMethod<Class_T, Method_T>::name()
-  {
-    return this->method_name_;
-  }
-
-  template<typename Class_T, typename Method_T>
-  inline NativeKind NativeMethod<Class_T, Method_T>::kind()
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  inline NativeKind NativeMethod<Class_T, Method_T, NoGVL>::kind()
   {
     return NativeKind::Method;
   }
 
-  template<typename Class_T, typename Method_T>
-  inline VALUE NativeMethod<Class_T, Method_T>::returnKlass()
+  template<typename Class_T, typename Method_T, bool NoGVL>
+  inline VALUE NativeMethod<Class_T, Method_T, NoGVL>::returnKlass()
   {
     // Check if an array is being returned
-    if (this->methodInfo_->returnInfo()->isBuffer())
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
     {
-      TypeMapper<Pointer<Return_T>> typeMapper;
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Return_T>>>> typeMapper;
       return typeMapper.rubyKlass();
     }
     else

data/rice/detail/NativeProc.hpp

@@ -12,7 +12,7 @@ namespace Rice::detail
     // 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 Parameter_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
@@ -23,11 +23,10 @@ namespace Rice::detail
     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;
+    NativeProc(Proc_T proc, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
+    VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) override;
     std::string toString() override;
     
-    std::string name() override;
     NativeKind kind() override;
     VALUE returnKlass() override;
 
@@ -36,14 +35,13 @@ namespace Rice::detail
 
     // 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);
+    Parameter_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
 
     // Call the underlying C++ function
-    VALUE invoke(Arg_Ts&& nativeArgs);
+    VALUE invoke(Parameter_Ts&& nativeArgs);
 
   private:
     Proc_T proc_;
-    std::unique_ptr<MethodInfo> methodInfo_;
     To_Ruby<To_Ruby_T> toRuby_;
   };
 }

data/rice/detail/NativeProc.ipp

@@ -9,8 +9,13 @@ 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);
+    // Create proc parameters
+    std::vector<std::unique_ptr<ParameterAbstract>> parameters = Native::create_parameters<Parameter_Ts>();
+
+    // Create return info
+    std::unique_ptr<Return> returnInfo = std::make_unique<Return>();
+
+    return new NativeProc_T(std::forward<Proc_T>(proc), std::move(returnInfo), std::move(parameters));
   }
 
   template<typename Proc_T>
@@ -30,19 +35,20 @@ namespace Rice::detail
 
   // 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)
+  VALUE NativeProc<Proc_T>::resolve(VALUE, VALUE callback_arg, int argc, const VALUE* argv, VALUE)
   {
     return cpp_protect([&]
     {
+      std::map<std::string, VALUE> values = readRubyArgs(argc, argv);
       NativeProc_T * native = (NativeProc_T*)callback_arg;
-      return (*native)(argc, argv, Qnil);
+      return (*native)(values, 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)
+  VALUE NativeProc<Proc_T>::finalizerCallback(VALUE, VALUE callback_arg, int, const VALUE*, VALUE)
   {
     NativeProc_T* native = (NativeProc_T*)callback_arg;
     delete native;
@@ -50,8 +56,9 @@ namespace Rice::detail
   }
 
   template<typename Proc_T>
-  NativeProc<Proc_T>::NativeProc(Proc_T proc, MethodInfo* methodInfo) : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
-                                                                        proc_(proc), methodInfo_(methodInfo)
+  NativeProc<Proc_T>::NativeProc(Proc_T proc, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters)
+    : Native("proc", std::move(returnInfo), std::move(parameters)),
+      proc_(proc), toRuby_(returnInfo_.get())
   {
   }
 
@@ -63,32 +70,32 @@ namespace Rice::detail
 
   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)
+  typename NativeProc<Proc_T>::Parameter_Ts NativeProc<Proc_T>::getNativeValues(std::vector<std::optional<VALUE>>& values,
+     std::index_sequence<I...>&)
   {
     /* 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
+       on the arguments (Parameter_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(this->getNativeValue<std::tuple_element_t<I, Parameter_Ts>, I>(values)...);
     return std::forward_as_tuple(
-      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Parameter_Ts>>*>(this->parameters_[I].get()))->
                convertToNative(values[I])...);
   }
 
   template<typename Proc_T>
-  VALUE NativeProc<Proc_T>::invoke(Arg_Ts&& nativeArgs)
+  VALUE NativeProc<Proc_T>::invoke(Parameter_Ts&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->proc_, std::forward<Arg_Ts>(nativeArgs));
+      std::apply(this->proc_, std::forward<Parameter_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_T nativeResult = std::apply(this->proc_, std::forward<Parameter_Ts>(nativeArgs));
 
       // Return the result
       return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
@@ -96,28 +103,22 @@ namespace Rice::detail
   }
 
   template<typename Proc_T>
-  VALUE NativeProc<Proc_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  VALUE NativeProc<Proc_T>::operator()(std::map<std::string, VALUE>& values, VALUE)
   {
     // Get the ruby values and make sure we have the correct number
-    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, true);
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(values, true);
 
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    auto indices = std::make_index_sequence<std::tuple_size_v<Parameter_Ts>>{};
 
     // Convert the Ruby values to native values
-    Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+    Parameter_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
     // Now call the native method
-    VALUE result = this->invoke(std::forward<Arg_Ts>(nativeValues));
+    VALUE result = this->invoke(std::forward<Parameter_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()
   {
@@ -127,7 +128,17 @@ namespace Rice::detail
   template<typename Proc_T>
   inline VALUE NativeProc<Proc_T>::returnKlass()
   {
-    TypeMapper<Return_T> typeMapper;
-    return typeMapper.rubyKlass();
+    // Check if an array is being returned
+    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
+    if (isBuffer)
+    {
+      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Return_T>>>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Return_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   }
 }

data/rice/detail/NativeRegistry.hpp

@@ -1,7 +1,6 @@
 #ifndef Rice__detail__NativeRegistry__hpp
 #define Rice__detail__NativeRegistry__hpp
 
-#include <map>
 #include <memory>
 #include <utility>
 

data/rice/detail/Parameter.hpp

@@ -8,19 +8,22 @@ namespace Rice::detail
   class ParameterAbstract
   {
   public:
-    ParameterAbstract() = default;
-    ParameterAbstract(Arg* arg);
+    ParameterAbstract(std::unique_ptr<Arg>&& arg);
     virtual ~ParameterAbstract() = default;
 
+    ParameterAbstract(const ParameterAbstract& other);
     ParameterAbstract(ParameterAbstract&& other) = default;
     ParameterAbstract& operator=(ParameterAbstract&& other) = default;
 
-    virtual Convertible matches(std::optional<VALUE>& valueOpt) = 0;
+    virtual VALUE defaultValueRuby() = 0;
+    virtual double matches(std::optional<VALUE>& valueOpt) = 0;
     virtual std::string cppTypeName() = 0;
     virtual VALUE klass() = 0;
 
-  public:
-    Arg* arg = nullptr;
+    Arg* arg();
+
+  private:
+    std::unique_ptr<Arg> arg_;
   };
 
   template<typename T>
@@ -29,19 +32,23 @@ namespace Rice::detail
    public:
      using Type = T;
 
-     Parameter() = default;
-     Parameter(Arg* arg);
+     Parameter(std::unique_ptr<Arg>&& arg);
+     Parameter(const Parameter& other) = default;
      Parameter(Parameter&& other) = default;
      Parameter& operator=(Parameter&& other) = default;
 
      T convertToNative(std::optional<VALUE>& valueOpt);
-     Convertible matches(std::optional<VALUE>& valueOpt) override;
+     VALUE convertToRuby(T& object);
+     VALUE defaultValueRuby() override;
+
+     double 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_;
+    To_Ruby<remove_cv_recursive_t<T>> toRuby_;
   };
 }
 #endif // Rice__detail__Parameter__hpp_